{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-09T13:37:05.382829Z",
     "start_time": "2025-03-09T13:37:05.191508Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "# 1. 沿轴 0 和轴 1 连接两个数组\n",
    "print(\"沿轴 0 连接两个数组：\")\n",
    "print(np.concatenate((a, b), axis=0))  # 沿轴 0（行方向）连接\n",
    "\n",
    "print(\"\\n沿轴 1 连接两个数组：\")\n",
    "print(np.concatenate((a, b), axis=1))  # 沿轴 1（列方向）连接\n",
    "\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "沿轴 0 连接两个数组：\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "\n",
      "沿轴 1 连接两个数组：\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T13:38:07.105334Z",
     "start_time": "2025-03-09T13:38:07.097903Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 根据轴进行堆叠,增加一个新的维度\n",
    "print(\"\\n沿轴 0 堆叠两个数组：\")\n",
    "print(np.stack((a, b), axis=0))  # 沿轴 0 堆叠\n",
    "\n",
    "print(\"\\n沿轴 1 堆叠两个数组：\")\n",
    "print(np.stack((a, b), axis=1))  # 沿轴 1 堆叠\n",
    "\n"
   ],
   "id": "88dd0d9f466883b2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "沿轴 0 堆叠两个数组：\n",
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n",
      "\n",
      "沿轴 1 堆叠两个数组：\n",
      "[[[1 2]\n",
      "  [5 6]]\n",
      "\n",
      " [[3 4]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T13:54:45.853075Z",
     "start_time": "2025-03-09T13:54:45.843356Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 矩阵垂直拼接\n",
    "v1 = [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]\n",
    "v2 = [[12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]\n",
    "result = np.vstack((v1, v2))  # 垂直拼接\n",
    "print(\"\\n矩阵垂直拼接结果：\")\n",
    "print(result)\n",
    "\n",
    "# 4. 矩阵水平拼接\n",
    "v1 = [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]\n",
    "v2 = [[12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]\n",
    "result = np.hstack((v1, v2))  # 水平拼接\n",
    "print(\"\\n矩阵水平拼接结果：\")\n",
    "print(result)"
   ],
   "id": "df2fb7891c38d5a0",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "矩阵垂直拼接结果：\n",
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "\n",
      "矩阵水平拼接结果：\n",
      "[[ 0  1  2  3  4  5 12 13 14 15 16 17]\n",
      " [ 6  7  8  9 10 11 18 19 20 21 22 23]]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T13:57:57.856020Z",
     "start_time": "2025-03-09T13:57:57.849925Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "\n",
    "# 1. 将数组分为三个大小相等的子数组\n",
    "arr = np.arange(9).reshape(3, 3)\n",
    "print('将数组分为三个大小相等的子数组：')\n",
    "b = np.split(arr, 3)\n",
    "print(b)\n",
    "\n"
   ],
   "id": "a6e3b08b24a9572a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "将数组分为三个大小相等的子数组：\n",
      "[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T13:57:52.411086Z",
     "start_time": "2025-03-09T13:57:52.404046Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 使用 numpy.hsplit 函数水平分割数组\n",
    "harr = np.floor(10 * np.random.random((2, 6)))#floor函数取整，ceil向上取整，round四舍五入\n",
    "print('原数组：')\n",
    "print(harr)\n",
    "print('拆分后：')\n",
    "print(np.hsplit(harr, 3))\n",
    "\n"
   ],
   "id": "2abe1b3cc51e7016",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原数组：\n",
      "[[9. 5. 4. 5. 4. 1.]\n",
      " [0. 2. 1. 6. 0. 4.]]\n",
      "拆分后：\n",
      "[array([[9., 5.],\n",
      "       [0., 2.]]), array([[4., 5.],\n",
      "       [1., 6.]]), array([[4., 1.],\n",
      "       [0., 4.]])]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T13:57:54.229240Z",
     "start_time": "2025-03-09T13:57:54.221612Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 使用 numpy.vsplit 函数沿垂直轴分割数组\n",
    "a = np.arange(16).reshape(4, 4)\n",
    "print('第一个数组：')\n",
    "print(a)\n",
    "print('\\n')\n",
    "print('竖直分割：')\n",
    "b = np.vsplit(a, 2)\n",
    "print(b)"
   ],
   "id": "d3516fbe0f01fc84",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第一个数组：\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "\n",
      "\n",
      "竖直分割：\n",
      "[array([[0, 1, 2, 3],\n",
      "       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],\n",
      "       [12, 13, 14, 15]])]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:12:25.396936Z",
     "start_time": "2025-03-09T14:12:25.391136Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "\n",
    "# 定义 nan 和 inf\n",
    "a = np.nan#np.nan 表示非数字（Not a Number）\n",
    "b = np.inf#表示无穷大（Infinity）\n",
    "print(a, type(a))  # 输出 nan 及其类型\n",
    "print(b, type(b))  # 输出 inf 及其类型\n",
    "\n"
   ],
   "id": "e558e751f6c61e64",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan <class 'float'>\n",
      "inf <class 'float'>\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:16:20.311525Z",
     "start_time": "2025-03-09T14:16:20.305044Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 判断数组中 nan 的个数\n",
    "t = np.arange(24, dtype=float).reshape(4, 6)\n",
    "# 将三行四列的数改成 nan\n",
    "t[3, 4] = np.nan\n",
    "\n",
    "# 使用 np.count_nonzero() 来判断非零的个数\n",
    "print(np.count_nonzero(t))  # 输出非零元素的个数\n",
    "\n",
    "# np.nan != np.nan 结果是 True,可以使用这两个结合使用判断 nan 的个数\n",
    "print(np.count_nonzero(t != t))  # 输出 nan 的个数\n",
    "\n",
    "# 将 nan 替换为 0\n",
    "t[np.isnan(t)] = 0#isnan函数判断是否为nan，返回布尔值\n",
    "print(t)  # 输出替换后的数组"
   ],
   "id": "73a0c7d35e08e2d9",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "1\n",
      "[[ 0.  1.  2.  3.  4.  5.]\n",
      " [ 6.  7.  8.  9. 10. 11.]\n",
      " [12. 13. 14. 15. 16. 17.]\n",
      " [18. 19. 20. 21.  0. 23.]]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:49:08.004186Z",
     "start_time": "2025-03-09T14:49:07.997379Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# 处理数组中的 nan\n",
    "t = np.arange(24).reshape(4, 6).astype('float')\n",
    "# 将数组中的一部分替换为 nan\n",
    "t[1, 3:] = np.nan\n",
    "print(t)\n",
    "print('-------------------')\n",
    "\n",
    "print(t.shape[0])#t.shape[0]表示行数\n",
    "print(t.shape[1])#t.shape[1]表示列数"
   ],
   "id": "3de1c0d0654a0e16",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  1.  2.  3.  4.  5.]\n",
      " [ 6.  7.  8. nan nan nan]\n",
      " [12. 13. 14. 15. 16. 17.]\n",
      " [18. 19. 20. 21. 22. 23.]]\n",
      "-------------------\n",
      "6\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:15:02.580577Z",
     "start_time": "2025-03-09T14:15:02.573021Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 遍历每一列，然后判断每一列是否有 nan\n",
    "for i in range(t.shape[1]):\n",
    "    # 获取当前列数据\n",
    "    temp_col = t[:, i]\n",
    "    # 判断当前列的数据中是否含有 nan\n",
    "    nan_num = np.count_nonzero(temp_col != temp_col)\n",
    "    # 条件成立说明含有 nan\n",
    "    if nan_num != 0:\n",
    "        # 将这一列不为 nan 的数据拿出来\n",
    "        temp_col_not_nan = temp_col[temp_col == temp_col]\n",
    "        # 将 nan 替换成这一列的平均值\n",
    "        temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)\n",
    "print(t)  # 输出处理后的数组"
   ],
   "id": "30062afff8ee8a0b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  1.  2.  3.  4.  5.]\n",
      " [ 6.  7.  8. 13. 14. 15.]\n",
      " [12. 13. 14. 15. 16. 17.]\n",
      " [18. 19. 20. 21. 22. 23.]]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:53:06.862541Z",
     "start_time": "2025-03-09T14:53:06.855890Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.arange(12).reshape(3, 4)\n",
    "print('原数组：')\n",
    "print(a)\n",
    "print('\\n')\n",
    "\n",
    "# 使用 np.transpose 对换数组\n",
    "print('对换数组：')\n",
    "print(np.transpose(a))\n",
    "\n"
   ],
   "id": "a2a55ca72cdc242d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原数组：\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "\n",
      "\n",
      "对换数组：\n",
      "[[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:53:24.868330Z",
     "start_time": "2025-03-09T14:53:24.862519Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 使用 .T 属性转置数组\n",
    "a = np.arange(12).reshape(3, 4)\n",
    "print('原数组：')\n",
    "print(a)\n",
    "print('\\n')\n",
    "print('转置数组：')\n",
    "print(a.T)\n",
    "\n"
   ],
   "id": "1f90ca1c1d7cfba1",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原数组：\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "\n",
      "\n",
      "转置数组：\n",
      "[[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:54:01.857751Z",
     "start_time": "2025-03-09T14:54:01.848077Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 使用 swapaxes 函数交换数组的两个轴\n",
    "t1 = np.arange(24).reshape(4, 6)\n",
    "re = t1.swapaxes(1, 0)\n",
    "print('原数组：')\n",
    "print(t1)\n",
    "print('\\n')\n",
    "print('调用 swapaxes 函数后的数组：')\n",
    "print(re)\n",
    "\n"
   ],
   "id": "b935ba4d0d5b2b91",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原数组：\n",
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "\n",
      "\n",
      "调用 swapaxes 函数后的数组：\n",
      "[[ 0  6 12 18]\n",
      " [ 1  7 13 19]\n",
      " [ 2  8 14 20]\n",
      " [ 3  9 15 21]\n",
      " [ 4 10 16 22]\n",
      " [ 5 11 17 23]]\n",
      "滚动轴后的数组形状：\n",
      "(4, 2, 3)\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T14:58:00.274177Z",
     "start_time": "2025-03-09T14:58:00.266504Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 使用 rollaxis 函数滚动轴\n",
    "t = np.arange(24).reshape(2, 3, 4)\n",
    "print(t)\n",
    "print('\\n')\n",
    "t = np.rollaxis(t, 2, 0)  # 将第 3 个轴滚动到第 1 个轴的位置\n",
    "print('滚动轴后的数组形状：')\n",
    "print(t.shape)\n",
    "print(t)"
   ],
   "id": "bd22f69bd58c228b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n",
      "\n",
      "\n",
      "滚动轴后的数组形状：\n",
      "(4, 2, 3)\n",
      "[[[ 0  4  8]\n",
      "  [12 16 20]]\n",
      "\n",
      " [[ 1  5  9]\n",
      "  [13 17 21]]\n",
      "\n",
      " [[ 2  6 10]\n",
      "  [14 18 22]]\n",
      "\n",
      " [[ 3  7 11]\n",
      "  [15 19 23]]]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T14:12:54.807736Z",
     "start_time": "2025-03-10T14:12:54.523692Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "us_file_path = \"./youtube_video_data/US_video_data_numbers.csv\"\n",
    "uk_file_path = \"./youtube_video_data/GB_video_data_numbers.csv\"\n",
    "\n",
    "# t1 = np.loadtxt(us_file_path, delimiter=\",\", dtype=\"int\", unpack=True)#unpack相当于转置\n",
    "t_us = np.loadtxt(us_file_path, delimiter=\",\", dtype=\"int\")\n",
    "\n",
    "# 取评论的数据\n",
    "t_us_comments = t_us[:, -1]\n",
    "\n",
    "# 打印最大值和最小值\n",
    "print(t_us_comments.max(), t_us_comments.min())\n",
    "\n",
    "# 计算分箱数量\n",
    "d = 10000\n",
    "bin_nums = (t_us_comments.max() - t_us_comments.min()) // d\n",
    "\n",
    "# 绘图\n",
    "plt.figure(figsize=(20, 8), dpi=80)\n",
    "plt.hist(t_us_comments, bin_nums)\n",
    "plt.show()"
   ],
   "id": "9d6eb63b08218a42",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "582624 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x640 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQsAAAIQCAYAAAAmdTgVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAxOAAAMTgF/d4wjAAAj6UlEQVR4nO3db2xV933H8c9lBroUvChkBOjFOJlNtwgCIXHlwRIWoayokUbWhEVKQsvUiD8SQpUrLTyYuj2oWJAiS0kmjaUPrE1IUVlhPKFZkrEGwoN0oJWmQVvAlIsxxXVLmm1ETWaPswc9uwpdYgg2vhC/XtKV8Pnee/gh7tGBt869p1IURREAAAAAYMKb1OgFAAAAAADXBrEQAAAAAEgiFgIAAAAAJbEQAAAAAEgiFgIAAAAAJbEQAAAAAEgiFgIAAAAApcuKhZs3b05ra2sqlUqOHDlS3/7+++9n06ZNaW9vz8KFC/P444/XZ8ePH8/SpUszf/78dHR05OjRo5c1AwAAAAAao+lynvTwww/nT//0T/N7v/d7F23fsmVLKpVKjh07lkqlkoGBgfps/fr1WbduXdauXZtvf/vbWbt2bQ4dOnTJ2aVMnTo1v/mbv3m5fz4AAAAA4AN++tOf5v333//QWaUoiuJyd9Ta2po9e/Zk8eLFeffddzN79uz09/enubn5oucNDg6mra0tb7/9dpqamlIURWbPnp2DBw+mubn5I2dtbW2XXEO1Wk1/f//lLhkAAAAA+ICR+toVf2fhiRMnctNNN2Xr1q25++67c88992Tfvn1JktOnT2f27NlpavrlhYuVSiUtLS3p6+sbcfZhuru7U61W64/z589f6ZIBAAAAgBFccSwcHh7OqVOncvvtt+fw4cN59tln88gjj+QnP/nJWK4vXV1d6e/vrz+mTZs2pvsHAAAAAH7pimNhS0tLJk2alMceeyxJcuedd+bWW2/ND3/4w8ydOzdnz57N8PBwkqQoivT19aWlpWXEGQAAAADQOFccC2+++easWLEiL730UpLk5MmTOXnyZH7nd34nM2fOzJIlS7Jjx44kya5du1KtVtPW1jbiDAAAAABonMu6wcn69euzd+/eDAwMZMaMGZk+fXp6e3vzox/9KF/5ylfys5/9LJMmTcrXv/71PPTQQ0mSt956K2vXrs25c+fS3Nycnp6eLFy48JKzS3GDEwAAAAC4ciP1tY91N+RrgVgIAAAAAFfuqtwNGQAAAAD4ZBELAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkSVOjF8DFWrfsHdP91Z56YEz3BwAAAMAnlysLAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAkYiEAAAAAUBILAQAAAIAklxkLN2/enNbW1lQqlRw5cuT/zXt6elKpVLJnz576tsHBwaxcuTLt7e1ZsGBBDhw4cFkzAAAAAKAxLisWPvzwwzl48GDmzZv3/2a1Wi3f/OY309nZedH2LVu2pLOzM8ePH09PT08effTRDA0NXXIGAAAAADTGZcXCe++9N9Vq9f9tv3DhQp544ok899xzmTp16kWznTt3ZsOGDUmSjo6OzJkzJ/v377/kDAAAAABojFF9Z2F3d3eWLVuWu+6666Lt586dy9DQUGbNmlXf1tramr6+vhFnAAAAAEDjNF3pC998883s2rXrqn/fYHd3d7q7u+s/nz9//qr+fgAAAAAwUV3xlYWvvfZaarVa2tvb09ramtdffz3r1q3LX//1X2fGjBlpamrKwMBA/fm1Wi0tLS0jzj5MV1dX+vv7649p06Zd6ZIBAAAAgBFccSzcuHFjzp49m1qtllqtls7Ozjz//PPZuHFjkmT16tXZvn17kuTQoUM5c+ZMli9ffskZAAAAANAYl/Ux5PXr12fv3r0ZGBjI5z//+UyfPj29vb0jvmbbtm1Zs2ZN2tvbM2XKlOzYsSOTJ0++5AwAAAAAaIxKURRFoxfxcVSr1fT39zd6GVdN65a9Y7q/2lMPjOn+AAAAALi+jdTXRnU3ZAAAAADgk0MsBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQOmyYuHmzZvT2tqaSqWSI0eOJEnee++9PPjgg5k/f34WLVqU+++/P729vfXXDA4OZuXKlWlvb8+CBQty4MCBy5oBAAAAAI1xWbHw4YcfzsGDBzNv3ryLtq9bty5vvfVWfvCDH2TVqlV54okn6rMtW7aks7Mzx48fT09PTx599NEMDQ1dcgYAAAAANMZlxcJ777031Wr1om2f+tSn8oUvfCGVSiVJ0tnZmVqtVp/v3LkzGzZsSJJ0dHRkzpw52b9//yVnAAAAAEBjjNl3Fj7zzDNZtWpVkuTcuXMZGhrKrFmz6vPW1tb09fWNOPsw3d3dqVar9cf58+fHaskAAAAAwAc0jcVOtm7dmt7e3uzbt28sdneRrq6udHV11X/+1SscAQAAAICxMeorC59++uns3r07L774Ym644YYkyYwZM9LU1JSBgYH682q1WlpaWkacAQAAAACNM6pY2N3dnRdeeCGvvPJKbrzxxotmq1evzvbt25Mkhw4dypkzZ7J8+fJLzgAAAACAxrisjyGvX78+e/fuzcDAQD7/+c9n+vTpefXVV/O1r30tt912W+67774kydSpU/O9730vSbJt27asWbMm7e3tmTJlSnbs2JHJkydfcgYAAAAANEalKIqi0Yv4OKrVavr7+xu9jKumdcveMd1f7akHxnR/AAAAAFzfRuprY3Y3ZAAAAADg+iYWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJxEIAAAAAoCQWAgAAAABJLjMWbt68Oa2tralUKjly5Eh9+/Hjx7N06dLMnz8/HR0dOXr06KhnAAAAAEBjXFYsfPjhh3Pw4MHMmzfvou3r16/PunXrcuzYsTz55JNZu3btqGcAAAAAQGNUiqIoLvfJra2t2bNnTxYvXpzBwcG0tbXl7bffTlNTU4qiyOzZs3Pw4ME0Nzdf0aytre2Sa6hWq+nv7x/VH/pa1rpl75jur/bUA2O6PwAAAACubyP1tSv+zsLTp09n9uzZaWpqSpJUKpW0tLSkr6/vimcfpru7O9Vqtf44f/78lS4ZAAAAABjBNX+Dk66urvT399cf06ZNa/SSAAAAAOATqelKXzh37tycPXs2w8PD9Y8T9/X1paWlJc3NzVc0AwAAAAAa54qvLJw5c2aWLFmSHTt2JEl27dqVarWatra2K54BAAAAAI1zWTc4Wb9+ffbu3ZuBgYHMmDEj06dPT29vb956662sXbs2586dS3Nzc3p6erJw4cIkueLZpbjBycfjBicAAAAAfNBIfe1j3Q35WiAWfjxiIQAAAAAfdFXuhgwAAAAAfLKIhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAErEQAAAAACiJhQAAAABAkjGKhd/5zneyZMmSLF68OAsWLMjf/u3fJkkGBwezcuXKtLe3Z8GCBTlw4ED9NSPNAAAAAIDx1zTaHRRFkccffzyvvvpq7rjjjtRqtfz2b/92vvjFL2bLli3p7OzMP/7jP+bQoUP5oz/6o5w8eTKTJ08ecQYAAAAAjL8xubKwUqnknXfeSZL853/+Z2bMmJGpU6dm586d2bBhQ5Kko6Mjc+bMyf79+5NkxBkAAAAAMP5GfWVhpVLJt771rXzxi1/Mpz/96fz85z/P7t2781//9V8ZGhrKrFmz6s9tbW1NX19fzp0795EzAAAAAKAxRn1l4fDwcL7xjW9k9+7dOXXqVPbt25c1a9ZkeHh4LNaX7u7uVKvV+uP8+fNjsl8AAAAA4GKjjoVHjhzJj3/849x7771JfvmR4mq1mjfeeCNNTU0ZGBioP7dWq6WlpSUzZsz4yNmv6urqSn9/f/0xbdq00S4ZAAAAAPgQo46Fc+fOzdmzZ/Nv//ZvSZLe3t6cOHEin/3sZ7N69eps3749SXLo0KGcOXMmy5cvT5IRZwAAAADA+Bv1dxbecsstef755/PHf/zHmTRpUi5cuJC/+qu/SktLS7Zt25Y1a9akvb09U6ZMyY4dO+p3Ox5pBgAAAACMv0pRFEWjF/FxVKvV9Pf3N3oZV03rlr1jur/aUw+M6f4AAAAAuL6N1NdG/TFkAAAAAOCTQSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABASSwEAAAAAJKIhQAAAABAaUxi4fvvv59Nmzalvb09CxcuzOOPP54kOX78eJYuXZr58+eno6MjR48erb9mpBkAAAAAMP7GJBZu2bIllUolx44dyw9/+MM8/fTTSZL169dn3bp1OXbsWJ588smsXbu2/pqRZgAAAADA+KsURVGMZgfvvvtuZs+enf7+/jQ3N9e3Dw4Opq2tLW+//XaamppSFEVmz56dgwcPprm5+SNnbW1tI/5+1Wo1/f39o1nyNa11y94x3V/tqQfGdH8AAAAAXN9G6mujvrLwxIkTuemmm7J169bcfffdueeee7Jv376cPn06s2fPTlNTU5KkUqmkpaUlfX19I85+VXd3d6rVav1x/vz50S4ZAAAAAPgQo46Fw8PDOXXqVG6//fYcPnw4zz77bB555JEMDw+PxfrS1dWV/v7++mPatGljsl8AAAAA4GJNo91BS0tLJk2alMceeyxJcuedd+bWW2/NqVOncvbs2QwPD9c/atzX15eWlpY0Nzd/5AwAAAAAaIxRX1l48803Z8WKFXnppZeSJCdPnszJkyezbNmyLFmyJDt27EiS7Nq1K9VqNW1tbZk5c+ZHzgAAAACAxhj1DU6S5Ec/+lG+8pWv5Gc/+1kmTZqUr3/963nooYfy1ltvZe3atTl37lyam5vT09OThQsXJsmIs5G4wcnH4wYnAAAAAHzQSH1tTGLheBILPx6xEAAAAIAPuqp3QwYAAAAAPhnEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgiVgIAAAAAJTEQgAAAAAgyRjHwp6enlQqlezZsydJMjg4mJUrV6a9vT0LFizIgQMH6s8daQYAAAAAjL8xi4W1Wi3f/OY309nZWd+2ZcuWdHZ25vjx4+np6cmjjz6aoaGhS84AAAAAgPE3JrHwwoULeeKJJ/Lcc89l6tSp9e07d+7Mhg0bkiQdHR2ZM2dO9u/ff8kZAAAAADD+xiQWdnd3Z9myZbnrrrvq286dO5ehoaHMmjWrvq21tTV9fX0jzgAAAACAxmga7Q7efPPN7Nq166p952B3d3e6u7vrP58/f/6q/D4AAAAAMNGN+srC1157LbVaLe3t7Wltbc3rr7+edevWZefOnWlqasrAwED9ubVaLS0tLZkxY8ZHzn5VV1dX+vv7649p06aNdskAAAAAwIcYdSzcuHFjzp49m1qtllqtls7Ozjz//PPZuHFjVq9ene3btydJDh06lDNnzmT58uVJMuIMAAAAABh/o/4Y8ki2bduWNWvWpL29PVOmTMmOHTsyefLkS84AAAAAgPE35rHw1Vdfrf/6lltuycsvv/yhzxtpBgAAAACMvzG5GzIAAAAAcP0TCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGIhAAAAAFASCwEAAACAJGMQC9977708+OCDmT9/fhYtWpT7778/vb29SZLBwcGsXLky7e3tWbBgQQ4cOFB/3UgzAAAAAGD8jcmVhevWrctbb72VH/zgB1m1alWeeOKJJMmWLVvS2dmZ48ePp6enJ48++miGhoYuOQMAAAAAxt+oY+GnPvWpfOELX0ilUkmSdHZ2plarJUl27tyZDRs2JEk6OjoyZ86c7N+//5IzAAAAAGD8jfl3Fj7zzDNZtWpVzp07l6GhocyaNas+a21tTV9f34gzAAAAAKAxmsZyZ1u3bk1vb2/27duXX/ziF2Oyz+7u7nR3d9d/Pn/+/JjsFwAAAAC42JhdWfj0009n9+7defHFF3PDDTdkxowZaWpqysDAQP05tVotLS0tI85+VVdXV/r7++uPadOmjdWSAQAAAIAPGJNY2N3dnRdeeCGvvPJKbrzxxvr21atXZ/v27UmSQ4cO5cyZM1m+fPklZwAAAADA+Bv1x5D7+/vzta99Lbfddlvuu+++JMnUqVPzve99L9u2bcuaNWvS3t6eKVOmZMeOHZk8eXKSjDgDAAAAAMbfqGNhtVpNURQfOrvlllvy8ssvf+wZAAAAADD+xvxuyAAAAADA9UksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSiIUAAAAAQEksBAAAAACSJE2NXgBXV+uWvWO2r9pTD4zZvgAAAAC49riyEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABIkjQ1egFcP1q37B3T/dWeemBM9wcAAADA6LiyEAAAAABIIhYCAAAAACWxEAAAAABIIhYCAAAAACWxEAAAAABI4m7INNBY3l3ZnZUBAAAARq+hVxYeP348S5cuzfz589PR0ZGjR482cjkAAAAAMKE1NBauX78+69aty7Fjx/Lkk09m7dq1jVwOAAAAAExoDfsY8uDgYA4fPpyXX345SfLQQw9l06ZN6e3tTVtbW6OWBWP68ejER6Sv1LX6MXXvDy7lWn3vAgAAXI6GxcLTp09n9uzZaWr65RIqlUpaWlrS19d3USzs7u5Od3d3/eeBgYFUq9VxX+94OX/+fKZNm9boZVx3qjsavYKPdi2v7Vo11sfBtfx3cC2vjcb5v2PA+4OJzL+JmOgcA+A4gKt5DPz0pz/9yNk1f4OTrq6udHV1NXoZ46Zaraa/v7/Ry4CGchww0TkGwHEAjgFwHECjjoGGfWfh3Llzc/bs2QwPDydJiqJIX19fWlpaGrUkAAAAAJjQGhYLZ86cmSVLlmTHjl9+xmrXrl2pVqu+rxAAAAAAGqShH0P+m7/5m6xduzZbt25Nc3Nzenp6Grmca8JE+sg1fBTHAROdYwAcB+AYAMcBNOoYqBRFUTTkdwYAAAAArikN+xgyAAAAAHBtEQsBAAAAgCRiIQAAAABQEguvIcePH8/SpUszf/78dHR05OjRo41eElyWzZs3p7W1NZVKJUeOHKlvH+k9Pd4zuJree++9PPjgg5k/f34WLVqU+++/P729vUmSwcHBrFy5Mu3t7VmwYEEOHDhQf914z+Bq+4M/+IPccccdWbx4ce655558//vfT+J8wMTT09OTSqWSPXv2JHEuYOJobW3NZz/72SxevDiLFy/Ot771rSTOA0ws77//fjZt2pT29vYsXLgwjz/+eJLr7DgouGbcd999RU9PT1EURfH3f//3xd13393YBcFl2r9/f3H69Oli3rx5xfe///369pHe0+M9g6vpF7/4RbF3797iwoULRVEUxXPPPVcsX768KIqi+JM/+ZPiz//8z4uiKIp/+Zd/KT7zmc8U//3f/92QGVxtP//5z+u/3r17d3HHHXcUReF8wMRy8uTJ4nd/93eLzs7O4h/+4R+KonAuYOL41f8P/B/nASaSr371q8WmTZvq/zc4e/ZsURTX13EgFl4jfvKTnxTTp08vhoaGiqIoigsXLhS33HJLcfz48QavDC7fB/9xMNJ7erxnMN4OHTpUzJs3ryiKovj0pz9d/wdCURRFR0dH8corrzRkBuOpp6enWLRokfMBE8r//M//FCtWrCgOHz5cLF++vB4LnQuYKD4sFjoPMJGcP3++mD59evEf//EfF22/3o6DplFcWckYOn36dGbPnp2mpl/+lVQqlbS0tKSvry9tbW0NXh18fCO9p3/jN35jXGeOIcbbM888k1WrVuXcuXMZGhrKrFmz6rPW1tb09fWN+wzGy5e+9KV897vfTZJ85zvfcT5gQunu7s6yZcty11131bc5FzDRfOlLX0pRFPnc5z6Xp556ynmACeXEiRO56aabsnXr1vzTP/1Tfv3Xfz1/8Rd/kRtvvPG6Og58ZyEAjKGtW7emt7c3f/mXf9nopUBD/N3f/V1Onz6db3zjG3nyyScbvRwYN2+++WZ27dqVP/uzP2v0UqBhDhw4kDfeeCP/+q//mptvvjlf/vKXG70kGFfDw8M5depUbr/99hw+fDjPPvtsHnnkkQwPDzd6aR+LWHiNmDt3bs6ePVt/AxVFkb6+vrS0tDR4ZXBlRnpPj/cMxsvTTz+d3bt358UXX8wNN9yQGTNmpKmpKQMDA/Xn1Gq1tLS0jPsMxtuXv/zlfPe73021WnU+YEJ47bXXUqvV0t7entbW1rz++utZt25ddu7c6VzAhPF/77PJkyfnq1/9al577TX/L2BCaWlpyaRJk/LYY48lSe68887ceuutOXXq1HV1HIiF14iZM2dmyZIl2bFjR5Jk165dqVarLpPmujXSe3q8ZzAeuru788ILL+SVV17JjTfeWN++evXqbN++PUly6NChnDlzJsuXL2/IDK6md955Jz/+8Y/rP+/ZsyczZsxwPmDC2LhxY86ePZtarZZarZbOzs48//zz2bhxo3MBE8K7776bd955p/7zCy+8kDvvvNN5gAnl5ptvzooVK/LSSy8lSU6ePJmTJ09m2bJl19dx8DG/q5Gr6N///d+Lzs7Oor29vbjrrruKN954o9FLgsuybt264jOf+Uzxa7/2a8XMmTOL3/qt3yqKYuT39HjP4Go6ffp0kaS47bbbikWLFhWLFi0qPve5zxVFURQDAwPF/fffX7S1tRW333578c///M/11433DK6mWq1WdHR0FAsWLCjuuOOOYsWKFfUvuXc+YCL64A1OnAuYCE6cOFEsXry4WLhwYbFgwYLiD//wD4uTJ08WReE8wMRy4sSJ4vd///fr/yb69re/XRTF9XUcVIqiKMYwogIAAAAA1ykfQwYAAAAAkoiFAAAAAEBJLAQAAAAAkoiFAAAAAEBJLAQAAAAAkoiFAAAAAEBJLAQAAAAAkoiFAAAAAEDpfwEqDLgPRfcjsAAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T14:11:50.668728Z",
     "start_time": "2025-03-10T14:11:50.237017Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "us_file_path = \"./youtube_video_data/US_video_data_numbers.csv\"\n",
    "uk_file_path = \"./youtube_video_data/GB_video_data_numbers.csv\"\n",
    "\n",
    "# t1 = np.loadtxt(us_file_path, delimiter=\",\", dtype=\"int\", unpack=True)  # 这行被注释掉了\n",
    "t_us = np.loadtxt(us_file_path, delimiter=\",\", dtype=\"int\")\n",
    "\n",
    "# 取评论的数据\n",
    "t_us_comments = t_us[:, -1]\n",
    "\n",
    "# 选择评论数小于等于 5000 的数据\n",
    "t_us_comments = t_us_comments[t_us_comments <= 5000]\n",
    "\n",
    "\n",
    "print(t_us_comments.max(), t_us_comments.min())\n",
    "\n",
    "# 计算分箱数量\n",
    "d = 50  # 分箱宽度\n",
    "bin_nums = (t_us_comments.max() - t_us_comments.min()) // d\n",
    "\n",
    "# 绘图\n",
    "plt.figure(figsize=(20, 8), dpi=80)\n",
    "plt.hist(t_us_comments, bin_nums)  # 绘制直方图\n",
    "plt.show()"
   ],
   "id": "a1bcfc412dc84f56",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4995 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x640 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T14:10:42.072348Z",
     "start_time": "2025-03-10T14:10:41.806426Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "us_file_path = \"./youtube_video_data/US_video_data_numbers.csv\"\n",
    "uk_file_path = \"./youtube_video_data/GB_video_data_numbers.csv\"\n",
    "\n",
    "# t1 = np.loadtxt(us_file_path, delimiter=\",\", dtype=\"int\", unpack=True)\n",
    "t_uk = np.loadtxt(uk_file_path, delimiter=\",\", dtype=\"int\")\n",
    "\n",
    "# 选择喜欢数小于等于 50 万的数据\n",
    "t_uk = t_uk[t_uk[:, 1] <= 500000]\n",
    "\n",
    "# 提取评论数和喜欢数\n",
    "t_uk_comment = t_uk[:, -1]\n",
    "t_uk_like = t_uk[:, 1]\n",
    "\n",
    "# 绘制散点图\n",
    "plt.figure(figsize=(20, 8), dpi=80)\n",
    "plt.scatter(t_uk_like, t_uk_comment)\n",
    "plt.show()"
   ],
   "id": "706051098722654a",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x640 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRIAAAIOCAYAAADEEvHcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAxOAAAMTgF/d4wjAABnKklEQVR4nO3de3zcdZ33/ffvNzNpMylpcyi0dJpMsS27UqBA0lZcLFr0Uu9ddC9FFKStrRRd9/LWuCs87vVeZN3Lwy52ddfdh8LSYgVUDopcl2cQiqzQJgo3Ui8rh84kgZY2mbTQTNJMZr73H2HGHGbmN5PM4Tczr+fjwUOb32TyncMvk3nP5/P9WMYYIwAAAAAAAADIwi73AgAAAAAAAAC4H0EiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAAR95yL6CQ5s2bp8WLF5d7GQAAAAAAAEBFOnbsmE6dOpX2WFUFiYsXL1Z/f3+5lwEAAAAAAABUpEAgkPEYrc0AAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcecu9AAAAAAAAgGpljFFPeEihgWEFWxvU0d4ky7LKvSxgVggSAQAAAAAAiqB/KKrNu/arLxKVz2MrFk9oebNfe7atU6DJX+7lAXmjtRkAAAAAAKDAjDHavGu/woNRxeJG0bG4YnGj8GBUW3btlzGm3EsE8kaQCAAAAAAAUGA94SH1R0YUT0wNDOMJo95IVD3hoTKtDJg9gkQAAAAAAIACCw0My+tJvxeiz2MrNDBc4hUBc0eQCAAAAAAAUGDB1gbF4om0x2LxhIKtDSVeETB3BIkAAAAAAAAF1tHepOXNfnnsqVWJHttSW7NfHe1NZVoZMHsEiQAAAAAAAAVmWZb2bFun9ha/fB5L/jqPfB5LwRa/9mxfL8tK3/YMuJm33AsAAAAAAACoRoEmvx7q2qie8JBCA8MKtjaoo72JEBEViyARAAAAAACgSCzLUmewWZ3B5nIvBZgzWpsBAAAAAAAAOCJIBAAAAAAAAOCIIBEAAAAAAACAI4JEAAAAAAAAAI4IEgEAAAAAAAA4yilIHBwc1Nq1a1P/rV69Wl6vV5FIREePHtXb3/52rVq1SmvWrNGjjz6a+r5iHAMAAAAAAABQet5cLtTS0qKnnnoq9e+bb75Ze/fuVXNzs7Zt26YNGzboJz/5ibq7u/WXf/mXOnTokHw+n2644YaCHwMAAAAAAABQerNqbb7tttu0fft2SdLdd9+tj3zkI5Kkzs5OnXnmmdq7d2/RjgEAAAAAAAAovbyDxF/96lcaGhrSn//5n2twcFCxWExLlixJHQ8Gg+rt7S3Ksel27typQCCQ+u/kyZP53hwAAAAAAAAAOcg7SLztttu0efNmeb05dUUXVVdXl/r7+1P/LViwoNxLAgAAAAAAAKpSXkHiyZMndffdd2vbtm2SJvZO9Hq9OnLkSOoyoVBIbW1tRTkGAAAAAAAAoDzyChK/+93v6vzzz9ef/MmfpL52xRVX6Otf/7okqbu7Wy+++KI2btxYtGMAAAAAAAAASi+v/uTbbrtN11577ZSvfelLX9I111yjVatWqa6uTnfccUdqunIxjgEAAAAAAAAoPcsYY8q9iEIJBALq7+8v9zIAAAAAAACAipQtX8t72AoAAAAAAACA2kOQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwlHOQeOrUKf31X/+1Vq1apXPPPVcf/OAHJUnPPvusLr74Yq1evVqdnZ06cOBA6nuKcQwAAAAAAABA6eUcJN5www2yLEt/+MMf9Nvf/lY333yzJOm6667Tjh079Ic//EHXX3+9tm7dmvqeYhwDAAAAAAAAUHqWMcY4XWh4eFhLly5Vf3+/GhsbU18/evSoVq5cqUgkIq/XK2OMli5dqscee0yNjY0FP7Zy5cqs6wwEAurv75/7vQIAAAAAAADUoGz5Wk4Vic8//7yam5v1+c9/Xh0dHbrkkkv00EMPqa+vT0uXLpXX65UkWZaltrY29fb2FuXYdDt37lQgEEj9d/LkyfzvHQAAAAAAAACOcgoSx8fHFQ6H9frXv149PT3613/9V1155ZUaHx8v9vqy6urqUn9/f+q/BQsWlHU9AAAAAAAAQLXy5nKhtrY22batq6++WpJ0wQUXaMWKFQqHwzp8+LDGx8dTbci9vb1qa2tTY2NjwY8BAAAAAAAAKI+cKhJbW1u1adMm/fSnP5UkHTp0SIcOHdIb3/hGXXjhhbrjjjskSffdd58CgYBWrlyp008/veDHAAAAAAAAAJRHTsNWJOmFF17Q9u3bNTAwINu29fd///d6z3veo4MHD2rr1q0aHBxUY2Ojdu/erXPPPVeSinIsG4atAAAAAAAAALOXLV/LOUisBASJAAAAAAAAwOzNeWozAAAAAAAAgNpGkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABH3nIvAAAAAACAbIwx6gkPKTQwrGBrgzram2RZVrmXBQA1hyARAAAAAOBa/UNRbd61X32RqHweW7F4Qsub/dqzbZ0CTf5yLw8AagqtzQAAAAAAVzLGaPOu/QoPRhWLG0XH4orFjcKDUW3ZtV/GmHIvEQBqCkEiAAAAAMCVesJD6o+MKJ6YGhjGE0a9kah6wkNlWhkA1CaCRAAAAACAK4UGhuX1pN8L0eexFRoYLvGKAKC2ESQCAAAAAFwp2NqgWDyR9lgsnlCwtaHEKwKA2kaQCAAAAABwpY72Ji1v9stjT61K9NiW2pr96mhvKtPKAKA2ESQCAAAAAFzJsizt2bZO7S1++TyW/HUe+TyWgi1+7dm+XpaVvu0ZAFAc3nIvAAAAAACATAJNfj3UtVE94SGFBoYVbG1QR3sTISIAlAFBIgAAAADA1SzLUmewWZ3B5nIvBQBqGq3NAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHDFsBAAAAAOTNGMMkZQCoMQSJAAAAAIC89A9FtXnXfvVFovJ5bMXiCS1v9mvPtnUKNPnLvTwAKAo+QCFIBAAAAADkwRijzbv2KzwYVTxhFIvHJUnhwai27NqvB7s21twbawDVjw9QJrBHIgAAAAAgZz3hIfVHRhRPmClfjyeMeiNR9YSHyrQyACiOyR+gxOJG0bG4YnGT+gDFGON8JVWCIBEAAAAAkLPQwLC8nvQVhz6PrdDAcIlXBADFxQcof0SQCAAAAADIWbC1QbF4Iu2xWDyhYGtDiVcEAMXFByh/RJAIAAAAAMhZR3uTljf75bGnvqn22Jbamv3qaG8q08oAoDj4AOWPCBIBAAAAADmzLEt7tq1Te4tfPo8lf51HPo+lYItfe7avZ9AKgKrDByh/ZJkq2hEyEAiov7+/3MsAAAAAgKpnjFFPeEihgWEFWxvU0d5EiAigaqWb2tzWPPEByrJF9eVeXkFly9cIEgHwRyAAAAAAAA5q5b1ztnzNW+K1AHCZdJ+qLG/2a8+2dQo0+cu9PAAAAAAAXMGyLHUGm9UZbC73UsqGPRKBGmaM0eZd+xUejCoWN4qOxRWLG4UHo9qya7+qqGAZAAAAAADMEUEiUMN6wkPqj4wonpgaGMYTRr2RqHrCQ2VaGQAAAAAAcBuCRKCGhQaG5fWk38/B57EVGhgu8YoAAAAAAIBbESQCNSzY2qBYPJH2WCyeULC1ocQrAgAAAAAAbkWQCNSwjvYmLW/2y2NPrUr02Jbamv3qaG8q08oAAAAAAIDb5BwkBoNBnX322Vq7dq3Wrl2r7373u5KkZ599VhdffLFWr16tzs5OHThwIPU9xTgGoHAsy9KebevU3uKXz2PJX+eRz2Mp2OLXnu3rq3KMPQAAAAAAmB3L5DiWNRgM6v7779fatWunfP0tb3mLNm/erK1bt+ree+/Vl770JXV3dxftWDaBQED9/f353H4Ampje3BMeUmhgWMHWBnW0NxEiAgAAAABQg7Lla3MKEo8ePaqVK1cqEonI6/XKGKOlS5fqscceU2NjY8GPrVy5ctY3FAAAAAAAAEB22fK1vPZI3Lx5s84991xt375dx44dU19fn5YuXSqv1ytpok2yra1Nvb29RTk23c6dOxUIBFL/nTx5Mp+bAwAAAAAAACBHOQeJjz76qJ5++mn95je/UWtrq7Zs2VLMdeWkq6tL/f39qf8WLFhQ7iUBAAAAAAAAVcmb6wXb2tokST6fT5/4xCe0evVqLV++XIcPH9b4+HiqDbm3t1dtbW1qbGws+DEAAAAAAAAA5ZFTReLw8LCOHz+e+ve3v/1tXXDBBTr99NN14YUX6o477pAk3XfffQoEAlq5cmVRjgEAAAAAAAAoj5yGrbzwwgt6z3veo3g8LmOMzjrrLH31q19VMBjUwYMHtXXrVg0ODqqxsVG7d+/WueeeK0lFOZYNw1YAAAAAAACA2SvI1OZKQJAIAAAAAAAAzF7BpjYDAAAAAAAAqE0EiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAkbfcCwAAAAAAAKg2xhj1hIcUGhhWsLVBHe1Nsiyr3MsC5oQgEQAAAAAAoID6h6LavGu/+iJR+Ty2YvGEljf7tWfbOgWa/OVeHjBrtDYDAAAAAAAUiDFGm3ftV3gwqljcKDoWVyxuFB6Masuu/TLGlHuJwKwRJAIAAAAAABRIT3hI/ZERxRNTA8N4wqg3ElVPeKhMKwPmjiARAAAAAACgQEIDw/J60u+F6PPYCg0Ml3hFQOEQJAIAAAAAABRIsLVBsXgi7bFYPKFga0OJVwQUDkEiAAAAAABAgXS0N2l5s18ee2pVose21NbsV0d7U5lWBswdQSIAAAAAAECBWJalPdvWqb3FL5/Hkr/OI5/HUrDFrz3b18uy0rc9A5XAW+4FAAAAAAAAVJNAk18PdW1UT3hIoYFhBVsb1NHeRIiIikeQCAAAAAAAUGCWZakz2KzOYHO5lwIUDK3NAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAUd5B4u7du2VZlu6//35J0tGjR/X2t79dq1at0po1a/Too4+mLluMYwAAAAAAAABKL68gMRQK6dZbb9WGDRtSX7vhhhu0YcMGPfvss9q9e7euuuoqxWKxoh0DAAAAACATY4y6QxHd09On7lBExphyLwkAqoY31wsmEgl9+MMf1r/927/pU5/6VOrrd999t5577jlJUmdnp84880zt3btXl112WVGOAQAAAACQTv9QVJt37VdfJCqfx1YsntDyZr/2bFunQJO/3MsDgIqXc0Xizp079cY3vlEXXXRR6muDg4OKxWJasmRJ6mvBYFC9vb1FOZZuTYFAIPXfyZMnc7/lAAAAAICqYYzR5l37FR6MKhY3io7FFYsbhQej2rJrP5WJAFAAOVUkPvPMM7rvvvtct1dhV1eXurq6Uv8OBAJlXA0AAAAAoFx6wkPqj4wonpgaGMYTRr2RqHrCQ+oMNud8fcYY9YSHdOjYSY2OJ1Tv8yjY2qCO9iZZllXo5QNARcgpSPzlL3+pUCikVatWSZKOHDmiHTt26KabbpLX69WRI0dSFYShUEhtbW1qaWkp+DEAAAAAANIJDQzL67E0Fp95zOexFRoYdgwSk+Hhk+Eh3f54SEdfGVU8IRlJliSvx6JVGkBNy6m1+aMf/agOHz6sUCikUCikDRs26JZbbtFHP/pRXXHFFfr6178uSeru7taLL76ojRs3SlJRjgEAAAAAMF2wtUGxeCLtsVg8oWBrQ+rf6Qay9A9FtWnnXn3glsf1hR//Xi8dH9X4ayGiNPG/tEoDqHU5D1vJ5Etf+pKuueYarVq1SnV1dbrjjjvk8/mKdgwAAAAAgOk62pu0vNmv8GB0Snuzx7bU1uxXR3uTpPQDWQJN9YonpBePjyhDFpky21ZpAKgGlqmij1ECgYD6+/vLvQwAAAAAQBmkCwnbmv3as329li2qlzFGm3bunRE22paUyOOdsb/Oo5suP0dXdCwvwq0AgPLKlq/NuSIRAAAAAAA3CDT59VDXRvWEhxQaGJ4xHCXTQJZ8QkRpZqs0ANQKgkQAAAAAQNWwLEudwea0bcfZBrLkanqrNADUEoJEAAAAAEBNyDaQRcre4pyc2pxslU5WOQJALSFIBAAAAADUhGwDWZYtmi+vbatvaGJ/xbHxuE5vnK8tbwiqvs6jep9nRqs0ANQagkQAAAAAQE2wLEt7tq3LOJDlzIXzM+6vCABgajPgasYY/pABAAAACoy/swEgM6Y2AxWofyiqzbftV28kKtuylDDmtU9K1ynQ5C/38gAAAICKlW0gCwAgM7vcCwAwkzFGV926Ty8MDGs8YTQWT2g8YfTCwLCuvnWfqqiQGAAAAAAAVAiCRMCFukMR9UaiaY+FI1F1hyIlXhEAAAAAAKh1BImACz1y8NicjgMAAAAAABQaQSLgQq+Oxsq9BAAAAAAAgCkIEgGXMcbowf/zctbLXHr24hKtBgAAAAAAYAJBIuAyPeEhDbw6lvH4GY3zmC4HAAAAAABKjiARcJnQwLB83syn5vY/WyHLskq4IgAAAAAAAIJEwHX88zyKjsXTHvPa0gVtTSVeEQAAAAAAAEEi4CrGGN3804MZj7e3NKijnSARAAAAAACUHkEi4CI94SG9ODSa8fin3nY2bc0AAAAAAKAsCBIBFwkNDMvrSR8U1vtsDZ8aL/GKAAAAAAAAJhAkAi4SbG1QLJ5Ie2w8YRRsbSjxigAAAAAAACYQJAIu0tHepOXNfnnsqVWJHttSW7Of/REBAAAAAEDZECQCLmJZlvZsW6f2Fr98Hkv+Oo98HkvBFr/2bF/P/ogAAAAAAKBsvOVeAICpAk1+PdS1UT3hIYUGhhVsnZjUTIgIAAAAAADKiSARcCHLstQZbFZnsLncSwEAAAAAAJBEkAgAAAAAAIACM8bQaVeFCBIBAAAAAABQMP1DUW3etV99kah8HluxeELLm/3as22dAk3+ci8Pc8CwFQAAAAAAABSEMUabd+1XeDCqWNwoOhZXLG4UHoxqy679MsaUe4mYA4JEAAAAAAAAFERPeEj9kRHFE1MDw3jCqDcSVU94qEwrQyEQJAIAAAAAAKAgQgPD8nrS74Xo89gKDQyXeEUoJIJEAAAAAAAAFESwtUGxeCLtsVg8oWBrQ4lXhEIiSAQAAAAAAEBBdLQ3aXmzXx57alWix7bU1uxXR3tTmVaGQiBIBAAAAAAAQEFYlqU929apvcUvn8eSv84jn8dSsMWvPdvXy7LStz2jMnjLvQAAAAAAAABUj0CTXw91bVRPeEihgWEFWxvU0d5EiFgFCBIBAAAAAABQUJZlqTPYrM5gc7mXggKitRkAAAAAAACAI4JEAAAAAAAAAI4IEgEAAAAAAAA4IkgEAAAAAAAA4IggEQAAAAAAAIAjgkQAAAAAAAAAjggSAQAAAAAAADjylnsBAAAAAIDMjDHqCQ8pNDCsYGuDOtqbZFlWuZcFAKhBBIkAAAAA4FL9Q1Ft3rVffZGofB5bsXhCy5v92rNtnQJN/nIvDwBQY2htBgAAAAAXMsZo8679Cg9GFYsbRcfiisWNwoNRbdm1X8aYci8RAFBjCBIBAAAAwIV6wkPqj4wonpgaGMYTRr2RqHrCQ2VaGVBcxhh1hyK6p6dP3aEIoTngIrQ2AwAAAIALhQaG5fVYGovPPObz2AoNDKsz2Fz6hQFFRDs/4G5UJAIAAACACwVbGxSLJ9Iei8UTCrY2lHhFQHHRzg+4H0EiAAAAALhQR3uTljf75bGnTmj22Jbamv3qaG8q08qA4qCdH3A/gkQAAAAAcCHLsrRn2zq1t/jl81jy13nk81gKtvi1Z/t6WZblfCVABUm286eTbOcHUF7skQgAAAAALhVo8uuhro3qCQ8pNDCsYGuDOtqbCBFRlWjnB9yPIBEAAAAAXMyyLHUGmxmsgqqXbOcPD0antDfTzg+4B63NAAAAqHnGGHWHIrqnp0/doQgb+gNAGdDOD7gfFYkAAACoaf1DUW3etV99kah8HluxeELLm/3as22dAk3+ci8PAGoK7fyAu1mmij5uDQQC6u/vL/cyAAAAUCGMMdq0c2/aNrpgi18Pdm3kzSsAAKgp2fK1nFub3/a2t+m8887T2rVrdckll+jJJ5+UJD377LO6+OKLtXr1anV2durAgQOp7ynGMQAAAKBQesJD6o+MTAkRJSmeMOqNRNUTHirTygAAANwn5yDx7rvv1tNPP62nnnpKXV1d2rp1qyTpuuuu044dO/SHP/xB119/ferrxToGAAAAFEpoYFheT/qKQ5/HVmhguMQrAgAAcK9ZtTbffvvt+spXvqKf/exnWrlypSKRiLxer4wxWrp0qR577DE1NjYW/NjKlSuzrovWZgAAAOSjOxTRVbc+oVh85p/EPo+lu67dwKRcAABQU7Lla3kNW9m8ebMefvhhSdKPfvQj9fX1aenSpfJ6J67Gsiy1tbWpt7dXCxcuLPix6UHizp07tXPnztS/T548mc/NAQAAQI3raG/S8mZ/2j0S25r96mhvKuPqAAAA3CXn1mZJ2rNnj/r6+vSP//iPuv7664u1ppx1dXWpv78/9d+CBQvKvSQAAABUEMuytGfbOrW3+OXzWPLXeeTzTAxa2bN9PYNWAAAAJsmrIjFpy5Yt+shHPqJAIKDDhw9rfHw81Ybc29urtrY2NTY2FvwYAAAAUGiBJr8e6tqonvCQQgPDCrY2qKO9iRARAABgmpwqEo8fP66XXnop9e/7779fLS0tOv3003XhhRfqjjvukCTdd999CgQCWrlyZVGOAQAAAMVgWZY6g826omO5OoPNhIgAAABp5DRsJRwO64orrtDIyIhs29bixYt18803a+3atTp48KC2bt2qwcFBNTY2avfu3Tr33HMlqSjHsmHYCgAAAAAAADB72fK1WU1tdiuCRAAAAAAAAGD2suVreQ1bAQAAAAAAAFCbCBIBAAAAAAAAOCJIBAAAAAAAAOCIIBEAAAAAAACAI4JEAAAAAAAAAI4IEgEAAAAAAAA4IkgEAAAAAAAA4IggEQAAAAAAAIAjgkQAAAAAAAAAjggSAQAAAAAAADgiSAQAAAAAAADgiCARAAAAAAAAgCOCRAAAAAAAAACOCBIBAAAAAAAAOCJIBAAAAAAAAOCIIBEAAAAAAACAI4JEAAAAAAAAAI4IEgEAAAAAAAA4IkgEAAAAAAAA4IggEQAAAAAAAIAjgkQAAAAAAAAAjggSAQAAAAAAADjylnsBAAAAAKqbMUY94SGFBoYVbG1QR3uTLMsq97KAmse5CSBfBIkAAAAAiqZ/KKrNu/arLxKVz2MrFk9oebNfe7atU6DJX+7lATWLcxPAbNDaDAAAAGBWjDHqDkV0T0+fukMRGWNmHN+8a7/Cg1HF4kbRsbhicaPwYFRbdu2fcXkApcG5CWC2qEgEAACAa9BmVzlyqWbqCQ+pPzKieGJqKBFPGPVGouoJD6kz2FyO5QM1jXMTwGwRJAIAAMAVaLNzp3ThrqRUNVM8YRSLxyUpVc30YNdGWZal0MCwvB5LY/GZ1+vz2AoNDBNWAGXAuQlgtggSAQAAUHaT2+yyBVMorUzh7qfetjqnaqZga4Ni8UTa647FEwq2NpTiZgCYhnMTwGyxRyIAAADKLpc2O5RWtj3UPvvAAXk96YPdZDWTJHW0N2l5s18ee+plPbaltmZ/qroRqFVO+4wWC+cmgNmiIhEA4CrsjwbUJtrs3CdbuBsZHpOl9L+bJ1czWZalPdvWzahqbGv2a8/29fx+R00r53YOnJsAZosgEQDgGuyPBqRXCwE7bXbuky3crfPYWjDPp0h0bErQmK6aKdDk10NdG6v+OQzkww3bOXBuApgNgkQAQFklA5JDx07qKw89q5dfOcX+aMAktRKwJ9vskm+qk2izK59s4e54wuimd52jm392MKdqJsuy1BlspqoUeI1bpiZzbla2WvigEe5DkAgAKLnkHz1Phod0++MhHXv1lGzL0qnxmW9YS/0HNeAmbqhYKRXa7NzHKdx9x5oleseaJbyJBWaB7RwwV7XyQSPchyARAFBSyT96egeHFU9If3xrmnlzcf6gRq1yS8VKqdBm5y65hrtUMwH5YzsH5CJTxWEtfdAI9yFIBIAq5rZ2h6l/9OT+ffxBjVpVixUrtNm5C+EuUBxs5wAn2SoOD58YrakPGuEuBIkAUKXc2O6QqboqG/6gRi2jYgVuQLgLFB7bOUCafcXhRza+ruY+aIR7ECQCQBVx++CSbNVV083z2koYwx/UqGlUrABA9aLit7bNpeJwJBbng0aUDUEiAFSJyX+MuHVwSbbqqiTbkpYsnK9PXraaP6hR86hYAYDqRsVvbZprxeF8r80HjSgbgkQAqALT/xhx6+CSTNVVkmRJ8nqsVECybFF9ydcHuBEVKwAAVBenYWpOFYcrFi/gg0aUDUEiAFSBfPYeLGe7Q7rqqrHxuE5vnK+tF6/QBW2LCEiANKhYAQCgejgNU8ul4tCyLD5oRFkQJAJABUvuiXhPT5/sHP5mcEO7A9VVAAAAqHSZBqXkwmmYWq4Vh3zQiHIgSASACpXLnohJbhtcwh89AAAAqFTZBqUEmvyO35/LMDUqDuFWljHGuQ+uQgQCAfX395d7GQBKaC6fBFYyY4w27dybdq/ByRhcAgAAABROpr/DPbalYItfD3ZtzOnv7XRhJHuFwy2y5WtUJAKoWHP9JLCSOe2JOL0CkT9GUAtq9YMFAACQXjH+NnAalNITHsqp64btflCpCBIBVKTpU4pj8YmdisODUW3ZtT/nTwIrVbYNmud5bb1r7Zm6omM5f4ygZtTyBwsAAGCmYv1t4DQoJTQwnPP2PWz3g0pkl3sBADAbuXwSWM2ybdCcMEZXdCxXZ7CZEBE1YfIHC7G4UXQsrljcpD5YqKJdXAAAqArGGHWHIrqnp0/doUjBX6uL+beB06CUYGvDrK8bqARUJAKoSIX8JLAS5bJBM1ArCtViBAAAiq8UXQTF/NuAv8MLj+1pKgsViQAqUrV/Euj0Ka1lWdqzbZ3aW/zyeSz56zzyeSY2eHbDVGaglJIfLKST/GABAACUX6m6CIr5twF/hxdW/1BUm3bu1VW3PqEbHzigq259Qpt27lX/ULTcS0spdgVtpaEiEUBFquZPAnP9lJYNmoEJ1f7BAgAA1aJUXQTF/tuAv8MLoxL2vWcf7pmoSARQkar1k8B8P6VNbtDMnoioZckPFjz21Oe/ZUmLT5uni9oWlWdhAABgilJ1EWT626CQRQf8HT53bt/3nn240yNIBFCxkp8E3nXtBt10+Tm669oNerBro5Ytqi/30mbN7S+mQLHMpmUk+T33/rpff/O2s9Xe7JfXllJ/xhvp2KundNm/POqq9hgAAGpVqboIqrXooNq4fXsa3pulR2szgLKby+a6yU8Cq2WQQq0PkUFtytYysmxRfdrfD+m+Z9mi+WpZME/HXj0lYyQjTfnU2A3tMUAhsCk9gEpVyu2JaD92P7dvT8N7s/QIEgGUFXtOTOX2F1Og0Iwx2nzbfoUGh5UwmrI3ztW37pNtS/1DI1N+P3zzQ53asrt7xn46vZERJdIUMjK9GdWE100AlSxZKTj991hbc3EqBaut6KDauH3fe96bpZdTa/Po6Kje/e53a/Xq1Tr//PP11re+Vc8995wk6ejRo3r729+uVatWac2aNXr00UdT31eMYwCqB3tOzFSK/VyAUsvWtvyjZw7rhYHhGQFgPGEUjkTT/n648pYn0raZpAsRk9zQHgOkk09bP6+bAKpBNW5PhNlxews6783Sy7kicceOHXrHO94hy7L0ta99TR/+8If1yCOP6IYbbtCGDRv0k5/8RN3d3frLv/xLHTp0SD6fryjHAFSPUk1tqySl/pQWKDantuXPPnAg6/enCxhfPjEqnye/bZ5r+VNjuFe+1YW8bgKoFlQKIsnNLei8N0svpyBx/vz5euc735n694YNG3TzzTdLku6+++5UdWJnZ6fOPPNM7d27V5dddllRjgGoHuw5kZ6bX0yB6bLt1Ta5empyC3KyeuoL//1cDQ3H8v6ZXo+tWJbyQ9uaGkDW+qfGKK1c9y90Oj/S7enJ6yYAoBq5OVjmvdlMs9oj8atf/are9a53aXBwULFYTEuWLEkdCwaD6u3tLcqx6Xbu3KmdO3em/n3y5MnZ3Bygqrl5Q3b2nMjMzS+mQJJTNZVT9dQjB4/J57E0nq0nOY14IqEzGufr5VdOzdhPZ9mi+fLatvqG+NQYpZdPheFsqgt53QQAoPR4bzZV3kHi5z//eT333HN66KGHNDIyUow15ayrq0tdXV2pfwcCgTKuBnCfQm/IXuhQ0u2b67qBm4NgVKZCPadyqaZyqp6SlDVEPL1xngZPjs34/dDe4tftH1qnLbvTt5mcuXA+5w1KLt8Kw9lUF/K6CQAAyi2vIPHmm2/W9773PT344IPy+/3y+/3yer06cuRIqoIwFAqpra1NLS0tBT8GIHezaZnKZnIo6bUtjcUTam6o02cvP0fvXLN0Vm/S2XMiOyZzotAK+ZzKpZrKqXrq0rMX6ycHjswIRWxLCrb49c1t6zOGhcsW1WdtM+FTY+SikB/W5FthOJvqQl43AQBAuVkmx/FuO3fu1J133qkHH3xQTU1//LRz69atCgaD+uxnP6vu7m69+93vVigUks/nK8qxbAKBgPr7++d2jwBVojsU0dW37tNYmjcpPo+lu67dkPObbGOMNu3cO+PNftJZrQ3as3324RZVdzNlus899sQUs3yDYKDQz6l7evp04wMHFE1TTuWv8+imy8/Rey8KOP7MF4+PZAxFli2q5/cDiqbQH9bkck5c0bE89bW5nJOcFwAAoJiy5Ws5VST29/frU5/6lM466yy9+c1vliTNmzdP+/bt05e+9CVdc801WrVqlerq6nTHHXekAr9iHAOQm0JsyJ58o/Lw74+qN0OIKEmhweFZVTkmsefETEzmRKEV+jmVSzVVLtVTThtY8/sBxVDoqn0p/wrDuVQXcl4AAIByySlIDAQCylS4eMYZZ+hnP/tZyY4ByM1cN2SfXKlhKfs+Zgkjwq0CYzInCq3Qz6lc92rLZdIdoUhlq8TquGJ8WDOb/QuZBAkAACrNrKY2A5WgEt/YFNJcNmSfXqmRC8KtwmIyJwqt0M+pfKqpCAqrV6Xu5VqMD2tmW2HI+QEAACoJQSKqUqW+sSmkubRMZarUyIZwq7CYzIlCK8Zzimqq2laM9uBSKdaHNZwTAACg2hEkoupU8hubQpvtG5pslRrplCPcqvaKUyZzotCK9Zyimqp2VfJersX8sIZzAgAAVDOCRFSdSn5jUwyzeUOTrVLDtqTG+T6dPDWuOm95wq1KqjidS+BJZQsKjecUCqmS93LlwxoAAIDZIUhE1ankNzZuka1SI9ji188/+Sb9uvd4WYKISqo4LUTgSWULCo3nFAql0vdyJVgHAADIn13uBQCFVulvbNwgWanR3uKXz2PJX+eRzzMRIu7Zvl62basz2KwrOparM9hc0jdduVScZmOMUXcoont6+tQdimScSD9XkwPPWNwoOhZXLG5SgWexfi4AlEryQyePPfU1oJL2ck0G6+V4PQMAAKhEVCSi6jCkojDcWqkx24pTY4x+/MwR3fiDAxqKjqXasovVEk2LPYBqR3swAABA7SFIRNXhjU3huLEFcjYVp/1DUV1z2z4dGoimvjY+VtyWaFrsAdQCt37oBAAAgOIgSERV4o1N9cqn4jTZxvyxO5/UwMlTaa+vWBWCtNgDqBVu/NAJAAAAxUGQiKrFG5vCmcvk4ULLteI0OegkPDisDHleSjEqBGmxBwAAAABUG4JEVDw3hVzVqBCThwvNqeJ06mRn5+srRoUgLfYAAAAAgGpjmSoaHRoIBNTf31/uZaCE3BhyVRNjjDbt3Ju2qi7Y4i/4voKF0h2K6Opb92kshxTRtqQVrQ1Fuy0E3QAAAACASpItX7NLvBagYCZXncXiRtGxuGJxkxqeUUUZednkMnnYjZKDTnKxorWhqBWCyRb7KzqWqzPYTIgIAAAAAKhYBImoWJUaclWSbIFccl9BN8o26ESSPJa0+LQ6/cfVF+rBro1atqi+hKsDAAAAAKAysUciKlYy5BqLzzxWjOEZtahSJw9nGnRiW1LLgjr9+1UXUh0IAAAAAECeqEhExarUkKuSJAM5jz01cHP75OHkoJP2Fr98Hkv+Oo98HksrWht0/8f+TOtWtBAiamJ7gO5QRPf09Kk7FGE7AAAAAABAVlQkomJlqjpze8hVSSp58rDTZOdax6AiAAAAAEC+mNqMipYuDEmGXOx7VziVPnm40tdfaJU6jRsAAAAAUHzZ8jUqElHRqDorjeTk4Urcc7LWKu9yCU1zGVRUiY81AAAAAKC4CBJR8Sop5KIyrrSMMdq8a3+q8i4Wn5jMEx6Masuu/VVXeZdraMqgIgAAAADAbBAkAiVSa5VxblBLlXf5hKbFHlREYA4AAAAA1YkgESiBWquMc4taqrzLJzQt5qAiAnMAAAAAqF52uRcA1IJcQh4UXrEr79wkGZqmkwxNk5LTuNtb/PJ5LPnrPPJ5JgatzGUa9+TAPBY3io7FFYubVGBeRbO9AAAAAKAmUZEIlEAtVca5STEr79wm39C0GIOKaqmVHAAAAABqERWJQAnUUmWcmxSr8s6NkqGpx556m7KFpslBRVd0LFdnsHnO90c+VZEAAAAAgMpDRSJQArVUGec2xai8c6NkaDp9f8K25tKFpgTmAAAAAFDdLFNFm1YFAgH19/eXexlAWumGUCRDnmWL6su9PFSJck5MNsZo0869aQPzYIufoUIAAAAAUAGy5WsEiUAJlTPkAUqBwBwAAAAAKhtBIgCgZAjMAQAAAKByZcvX2CMRAFBQySEuTGgGAAAAgOrC1GYAAAAAAAAAjggSAQAAAAAAADiitRmuVui91ti7rXrwWAIAAAAAUFoEiXCtdNNflzf7tWfbOgWa/LO7vtv2KxyJpr7W3uzXnu2zuz4UX6awsNDPDQAAAAAA4IypzXAlY4w27dyr8GBU8cQfn6Ie21Kwxa8HuzbmXH1mjFF3KKIde36t4yOxGceXLZqvx65/C9VsLpMpLPzmhzq1ZXd3QZ4bgJtRdQsAAACgHJjajIrTHYqod1pQJEnxhFFvJKqe8FBOE2GTYdShY8PKlJi/eHxU+w8Nav1ZrQVYOQrBGKPNu/anwsJYPC5JCg9GdeUtT2jg1bE5PzcAN6PqFgAAAIAbMWwFrtM/FNXH7vqNxhPpoz+fx1ZoYNjxepJhVGggc4iY9J3uvlmsFMXSEx5Sf2QkbVj48olR2RmKsnJ9blS6ZJXtPT196g5FlK6wPJfLwJ0mB+mxuFF0LK5Y3Cg8GNWWXft5LAEAAACUDRWJcJXkG+jBk2MZLxOLJxRsbXC8rmQYlSGPnOJ4dGbLM8onNDAsr8fSWHzmMa/HVizDg5rrc6OSpatUCzTV62/+29mKnoor2NqgJY3ztWU31WyVKluQTtUtAAAAgHIiSISrOIV/tiW1NfvV0d7keF3ZwqjpLj17cZ4rRTEFWxsUiyfSHosnEjqjcb5efuXUjD0Sc31uVJLJ++S1t/h1w32/VTgyteX70EBUH7vzSfnrPBobj8uyLCUSUtxMbQvfsms/e0hWgGy/u5JVtwSJAAAAAMqBIBGu4hT+tS6Ypz3b1+cUhGQLoybzWNI1G9rzXSqKqKO9Scub/WkHqrS3+HX7h9bNqLhra/bn/NyoFNOrD0+Nx5XtKR1NnTgzk/i5VLMx9KO0sv3uqoWqWwAAAADuRZAIV8n2BtpjS1+76gItW1Sf03Ulw6jQwHDW9ubvfuQNsm22C3UTy7K0Z9u6GS28ybBw2aJ6PdS1sarDrUwDZ+ZiNtVsDP0ovWxBejVW3QIAAACoHJapol3bs42nRmUwxmjTzr1p30AHW/x5t2UmQ5DewWHFE3+s07IkNS+o0/1/dbGWN1Pd41a1VAk3/bYaY/TB/9yvsRyqanPl81i669oNM4LETPdzoc9H5C5dgDs5SAcAAACAYsmWrxEkwnUK/QY6GZIcOnZSo+MJ1fs8VR9KFVotBXrlkO45v8jv08nRcY3EChMkZgr/slUcHj4xqqtv3Zc2zMwUSpZaNT83q/m2AQAAAHAvgkRUHN5Au0cltra69fmTbl2S0lb92ZaytuR7bUs+j5U2aLStieBw4v9bGk8YLWmcp+9e94Ypj5lTxeFHNr5ONz5wYNLei3/kr/PopsvP0RUdy/O+Hwpl+nNzbDyu0xvna+vFQV3Q1uSaxx0AAAAAKkm2fI09EuFKlmWpM9hc9mqnWpdpnz43TwB2a/CZaV2fettq9UdGpgR50h9DxOmBose21N5cry++5zyFB6NqmOfVzT89qL6hqRW8X3rPufr4d57SyydG5fXYevmVUW3etX/K/ZCckj79ZycHs4zE4q4d+pHpufnS8VF94Ue/l9djueJxBwAAAIBqQpAIICOnoGk2E4CLya3BZ7Z1ffaBAxknlc/32Tptnk/HR8bStvmvW9EiSXrHmiVTKh0valuky/7lUb38yinFjRQfT6R+3uT7IduUdJ/H1nyv7ZqhH+n2kEz33JQm9kKNxU3ZH3cAAAAAqDYEiQAycgqa8p0AXGxuDT6zrSsyPCZL6UOueMLo36++IBX6ZWrTnl7B2x2K5HQ/ZJuSHosntGLxgqzTs0sVzmXaQ9JjS8oyzLrcjzsAAAAAVBuCRFQEt+55N5kxRt2hiB45eEySdOnZi9UZbHbdOvPhFDSVs7U1HbcGn9nWVeextWCeT5HoWNqqv+RzKJ9153o/dLQ3OVYcWpalh7o2lu38y1TNOXhyLOsekkluDLwBAAAAoFIRJML1+iJRXXnL4zpyYlT2a+HFREWUe/Y+6x+K6gO3PqG+yEjqa//xyPNqa/brrmvXu2ad+colaHITtwaf2dY1njC66V3n6OafHVRfJCqvbWksnlBzg0+fetvZBf95k+8Hy7Jyqjgs556lmao5M+0hOZ0bA28AAAAAqFR2uRcAZNMXGdabb35ELx0fVcJMhC7jCaMXBoZ19a375Iah48YYXXPbvikhYlJvZGKPNjesczaSQVN7i18+jyV/nUc+z8RE31K2tuYqGXwmJxYnlTv4dFrXO9Ys0UNdG/XV91+gBfN8smRp+FRc//d3ntSmnXvVPxQt6M+bfD8Emvx6qGuj7rp2g266/Bzdde0GPdi1UcsW1c/+BhdQsroynfk+Wy0N8+S1lbY5vNyPOwAAAABUG8tUasKRRrbx1Kg8xhhd/MWHdPjEqYyXufu6DamBE+XSHYroA7c8ofEMZVFe29K3d2yo6NbKfFrLy92Gnm4/vckDSsrFaV3GGG3auTdt9WewxZ/3wBC33g/56g5FdNWtTygWn3l++TyW7vzwRKD9ZHhItz8e0rFXT1X07QUAAACAcsuWr9HaDNfqCQ/p5Vcyh4iS9MjBY2UPEkMDw7Kz5Dv2a4MyKjlIzLW1NV14tbzZrz3bSteGnqywc9uemk7rKvSgGLfeD/lyaq+fvIfktW86q+JvLwAAAAC4WU6tzR//+McVDAZlWZaeeuqp1NefffZZXXzxxVq9erU6Ozt14MCBoh5DbXEK6Nwi2NqgeJbC3oQxNbFH2+ShGLG4UXQsrljcKDxY+vbuZLB0RcdyVw28ybaubC28yYEhhfx5lSKf9vrJt7ejvUk94SHd09On7lCkYrcXAAAAAAA3yaki8b3vfa8+/elP68/+7M+mfP26667Tjh07tHXrVt17773aunWruru7i3YMtSXY2uA4lfXSsxeXZjFZdLQ3qa3Zr0MD6fexa2+pjT3aCl1R5xalatV266AYN8i3utINlbEAAAAAUI3y2iMxGAzq/vvv19q1a3X06FGtXLlSkUhEXq9XxhgtXbpUjz32mBobGwt+bOXKlY7rY4/E6mKM0Vu+/EjGgK6tuV57//bNrqiySje1WZoIEe+6dkNN7NF2T0+fbnzggKJj8RnH/HUe3XT5ObqiY3kZVjZ7pQykCr1HYq2q5vux3PuPAgAAAKgNRdkjsa+vT0uXLpXXO3EVlmWpra1Nvb29WrhwYcGP5RIkorpYlqVvbV+fNqBra67Xt3e8wTVvogNNfj36t29WdyiiRw4ekzRRLVmp7aSzUW0VdZNbteMJo1h8IiBNtmoXOpBKtvBmGpBSK8+juaqWytjpoeGSxvnaspsqSwAAAADlVdHDVnbu3KmdO3em/n3y5MkyrgbFUEkBnWVZWreipezDX8rFaShGpbV3lyOQqpYBKeWU3GsyTWFsaq9JNwWJ6aoMXzw+MiVQHhuPy7IsJRJS3BQ/1AYAAACATGYdJC5fvlyHDx/W+Ph4qg25t7dXbW1tamxsLPixdLq6utTV1ZX6dyAQmO3NgYvVekBXKQpRUeem1s1yBVK5TsiuNLW212Qutzdd63ygqV7xhPTi8ZEplbDSzF1IKq3KEgAAAEDlm3WQePrpp+vCCy/UHXfcoa1bt+q+++5TIBBItSAX4xgAd5tLRZ3bBmS4JZCqBoV+bLOFdMWojM03BM3l9mZrnXcaMjWZG6ssAQAAAFSvnIatXHfddfrhD3+oI0eOqKWlRaeddpqee+45HTx4UFu3btXg4KAaGxu1e/dunXvuuZJUlGNOGLYCVB5jjLpDEX3szic1OHxqSohSzgEZxhi96Z8fnrE/p+SuQT/lkE+wls/wk9lW8U0P6dJdJlkZm+/go3xD0Fxvb3cooqtv3aexDGF1rnweS3ddu4EgEQAAAEDBZMvX8pra7HYEiUBlSAZGT4aHdPvjIb38yqgy5SnlCkqMMdr4z4+oNzJzanh7i1+P/M2lNREk5jT0o8mvv/lvZ2v41PiUANAYo289EdZND/xO8TQvNZMf21yr+AoZSuZy2/OdAJ0tIJx8e7NNOc9VNUyiBgAAAOA+RZnaDABOsg2S6B0cVjyRbue3qcrVutkTHtKRE6Npj710fKSi9qWbbag2PdzLNPTjhYFh/dWdv1G9z9Z4wmh5s1//9J7z9On7np4I4TJ8XpV8bDvam3KakJ3PAJxC7DU5m4E7ue6tma11XpJsS1Oqc21rIjhMXg8TvQEAAACUA0EigKJwHiSR2/WUaz9CN07/nU0gONv9CTPt4Zct+h2JTTyooYFhfeDWJ5QwmhHCTZZ8bHMN7Er9mMzm5+W6t2a2vRyXLZovr22rb2hqa/Y3t63T4ROjrhhGBAAAAKA2ESSiLNw0nReFV6hBEnMZkDFXbhu2kmvrb/K8am/xyxijv/72kxo8OaaE0ZTHYfNt+/TF95yn8GA07TnYHYqod1rIlauEkRLx7N83+bG999f9c67iK8ZjMpufl+uwF6cp52cunJ/2d2SgyV8xlbAAAAAAqg9BIkrObdN5UXiZKszyyaS8tqX2lvK1bhZj+u9sZQtmk62/yZbxvkhUHtvSaCxzyWc8YfTCQFRX3bpPdd6Z52D/UFQfu+s3Gp9FiJgLjyUFJz22hajiK/RjYoyRMUaL/L5UEJvLz3MKCCc/l52mnM+1NRsAAAAACo1hKyip2QwvqBbJ6cSPHDwmSbr07MXqDDZX5e2dyyAJ25JaFtTp36+6sGD3T6H2CJzL9N+5cBrgceeH1+uG7/12xnmVj+Q5+PNPvkmX/cujCg0M5xX85vNzbvyL1+uaDe1TBqPk+nuhUI9JtufE5J/hta1Uy/Z8n614wuT086i6BgAAAFCpGLYC18i2F1poYFjfeiI8JWDIxE1v0p3WYozRj585os98/xlFomOpr//HI8+rrdmvu65dX3WVmPkOkpAkS5LXYxU8qJtLBaxTxVguCvFcDQ0My7YlpcllPbalRw4eS3te5SO5H+Ed+3rVHxnJGCImHydpou04XVicHAwyfY/EZDA4/RwvVBVfrvd1tufEskX106o/Teo2Nc736WtXXZBTwF2IYS8AAAAA4DYEiSiq6W/ssw0viBvpsw8c0O3/FdKe7VNDnsnX0zDPq5t/enDKIIJytUY7hVT9Q1Fdc9s+HRqIpv3+3sjUqbTVIp9BEmPjcZ3eOF9bL16hC9oWFTQUzqUluJiBUKHa+Ntb/BlblUdjCRljMp5X+fB5bD3z4oms17X4tHn63l9dnBr64Z/n0c0/Paj+oZEpAeA/vfc8/e29TzsGg0n5hLbpHpNc72un58QX/vu5Gdvyh6Jjsiwr7Zqm/667qG2Rft173BUfdgAAAABAoRAkomjSvbFffNq8rJVqCSO9MDCsq2/dp0f+9lJZlpWxzVDSrIKh2UoXFGQLJH7+yTeljmcTHvzjVNpqYVmWvvmhdbrylsd15MSo7Ncek+Seh5kGSczW5MemrbleB4+8qmdeekWnzfeqL0277/RpwMVQiBAzV0sXzs96Xk1mS8p0yVg8oTXLFur7T76Y9rjHlr521QUKNPmnDP1455qlaR/PfKs5Zxva5nNfO02IfuTgsZwGv2T7cGNsPJ76eeX+sAMAAAAACokgEUWR6Y39kROj8thW2tbWycKRqLpDEXUGm9O2GU5X7GAoUyh67NVTGQMJpxbRJNuyUuFEtegfiuqq/3xCLx0flSQlXtuKdWx8onpurm2fmUIc25JOjefW3js5FCoGp8Aqn+dqeDCqep89JURPqvd5VF/nTVsBms6ON63Qz353VOFI+oElH1zfptt/Fcq4X2G6NWd6PEvV3pvPfZ2tKtrnsSXJcfBLLh9uSGbKv0vxYQcAAAAAFJtd7gWgOmWb2muMUVNDneN1fHt/r/75pwfVm+MAiWQwVGiTQ9FY3Cg6FlcsbnT4xKjGMwSbk1tEnSSMSU2lrQbGGF1z2z71RUZmHOsbGtGWXfuV74yn5KCae3r69KPfHtamL+/VVbc+ob//wTP6qzt/oxcGhhWLm5xDRGnqNOBiSAZW6STD41wFWxsyTlAeT0zcjj3b1qm9xS9Plt/qXlva9Pol2rN94rI+jyV/nUc+j5Waomzbduq60h13YwiW7b6e/nvBaUL0pWcv1vJmvzz21OtLBq2TK5FjcZM23E1ncqhZLJPPk+5QJO/zDAAAAACcUJGIonCq+jlv2UI9cvCYsr3N/cGTL8nrsTIGKNPNJRjKNqQhUyia7T26U4voZO0tfnW0N81q3W7UEx5KGyIm5dvKnb36a/YTituai3u/ZwusTo0n9C8P/kFveF1LTq2u2facTN6OZCtxdyiij935pAZOnppyftmW1N6SW9txIYbMlJJTODj594LTfdkZbM46+OXXvcdnPdjGtiwdOnayZFXTtFMDAAAAKDQqElEU2d7Yj8QS2usQIkoT+7iN5RgUzTYYMsboR789rHX/8yF94JYndOMDB3TVrU9o08696h+a2NswW7WTpYmAJt1aPri+LW1l02TtLq7ymq3QwPCM+2SyfKrxpleD5lr9lUkpq+uSgVWmx//IidGcqzOTU42dqgQty9K6FS36/scu1orFDVMuu6K1YcZlO4PNuqJjedopxE7H3STTfZ3u90Iu92UySL3r2g266fJzdNe1G/Rg10YtW1Sf9feBk1PjCX3loWdTv1sKJVPVdLKdmspEAAAAAIVCRSKKIlPVT9Lc4qA/8td5HKfBZpJuovL42Mz9zLKFoh5bOr1xvo69empG5VKyRXRyNd2p8YQa53u1/qwWndXaoDf/yek6c+H8ud0JLhNsbVA8S3CRrpU7U0VopmrQ2VhY79PfvfNPtGLxgpJU1yUDq/d94/HUXpGTJYzy2isxnyrBSqsonKvkfZ2pinD67c7l/pm8v+Pk5+dILK6x8dmPx375lVMF3yuxkPtxAgAAAEA2BIkoiuQb+/ff8rj6h2aGKLNV57FlZLR4QZ02/ekZOm2+T5eevTjviqlEIqH3feNxHU4T8EhT34Bna4Vsb/Hr5598k37dezynFlH/PI9u/ulB/eL3R/VLj63/fOxQ1bUfLmmcp2yPxBmN83RR26LUv7O1ZIYGhmXbkmaf26REx8a1YvGCkgYqgSa/PrFplf7fHxzQqfGZYXS+A1/yGV5SqkEnbpFveJrr/ZPu+WlZlmzLOA5SSqcY4Z7TVhLVNswJAAAAQPnQ2oyiOXPhfA2fyi8B8tozW4WTPLb0vs6AFp82T0dfPaX7fvOibv3lC7rhe7/Vi8cz78k3WbKV+cLPPaiXjo9mba9OvgF3aoW0bTunFtH3XhTQl3/2B/VGRqq2/dAYoy27uzMGLJakl18Z1WX/8qj6h6KpwSyh14alTL9P2prrNZpHO7M3y2+0Yg3jcbJi8YLU1Orpij3wpdYUuh07U8twIjHRoj9bhX4u5rNH5HTJAS13d/dqz+MhBrUAAAAAyIqKRMxKtuEk0kQVz/u+/riGorG8r3vJwvl6+ZVTU6r/bEtqaZinh/7Pyzr66pjiifRtyNmCg77I8EQV4olTOa1jJBbXyNi4jDF5Vzulu39K3X7o9BgVQ/I2ZgoSjaTxxEQF1ZZd+9X11tVTWsuTkvfJwSOv5vRzz1w4T5/583P0zIsndMujL6Qd0FOu0C6XQSlwp4znrDHyWJZ8HmtWA38K/Vyc7XMsWW3ZOziseGLi/LQkeT1W1VVKAwAAACgMgkTkzWk6aLKK5/CJ/Fqak63Ct39onbbsnrh+25rYVzBhpOPRsbTDV3IJ4voiUb3ly3vzetNvjPT3D/xO//lYSHddu16BJn/erZDJfRFPm+fR8ma/4on0VUOFbj8s1wTXbC2WkyXMxGX/7vvPZLyM17b0zEuvqN5nZx2yMs9r65NvPVvvPHep3rFmiX5y4IirQrt89++De2R7PnttS+MZqgCzKcZzcTbPseTv6dDA8JTg30hTqoILuZcjAAAAgMpHkIi8TG71iyeMYvGpVYGf/8s1+k53n0IDw45TmSfzeazUm95li+r1zQ91zqgezDbBOVsQZ4zRlbc8PqvKIWliIIbTG+pk9d+hYyf1lYeeTVVUJn/midG4TryUubqukBVKTo9RMYOBbC2W08WN9Mpo5orVsXhCa5Yt1PeffDHr9Uwe3uLW0C6fitZyVJKWSqXdtmzP54QxOmPhfB05MZrTXonJSr9iPRfzrZp2qh5mUAsAAACAdAgSkZds7bnPHxvWlbfsy+v66jyW3n3BMl3RsTz1pje5z97Lr+TWgixJp2JxRcfGtf/QoMKD0RmTf/O5rnTCg5nfUE+u/ktWUOaj0BVKs22hLkTI09HepEBTfdp25XS8tpUxIG5uqNMH17fp9l+FZlRNJaW779w6sTiX4R7lqiQthUq8bU4tw7d/qFNbdndPaQ2erN7nUSwe1+mN87X14hW6oG1RUZ+L+QzYyaV6mEEtAAAAAKYjSERecm1dzZWRUoMRkpwqZdKJG+nGB34nSar32RpPmCmTf322NSNYy4dtWWnfUE+v/psZJWTnsSamGF/Z2ZaaED3XkGE2E1z7h6K65rZ96o1E5bEsjSeMzmicpw+9cYUuaGvKeV2WZelv/tvZ+tidT+a01mxFojddvka2bacqDNPt45apuqsSJxaXs5K02Cr1tjlVuC5bVJ8KrQ8dO6nR8YTqfR61t0wEo9M/1HCTXKqHGQYEAAAAYDqCROQln9ZVJ5kq8eYaVib300uGFF/47+cqPscJpJPbZyfLVP2XC49t6bR5Hh179ZS+8uAfClahle8EV2OMPnDrE+qLTEy+jr8Whh4+cUpf+NHv8x68ED0Vl7/Oo6jDA+i1pdMb56UdrLOitUHvWLNE0tQKw8lhjVsDmtkq9TCeUqrk2+ZU4ZottF63oqXUy81Zstoyn2pfAAAAALDLvQBUluSbT4+dX3hjaaL6zmNb8td55PNYCrakryZzCistSS0L6uS0hHjCKDQY1e8Pv6JAU33GJ/uH/ywor8OZ0N6S/g11MvScjXjC6JXRccXiRtGx+JQBBybP4NMYo+5QRPf09MkYo+VNMx8jj21peVO9jDG6p6dP3aFI6vuSIeKM65XyXlcuYfPEYJ0GfXfHG9Te4pfP88fnxYrWhhnPi2RY877ONm1+QzBVxVotIaKU/bmUrCStVJV+25LPv2p63iWrLYOtDfLaE79XpYn/zfb7GQAAAEBtoyIReZnc6tc7GNV4DpV4tqTPvuscfXB9m37de9xx37pM+5IlnbW4QVd2tunLPzvouB9hPGF00//6nZY11cu2pelDk21Jv/j9UbU1Nyg0mL4yx2tb+tJ7z5MkdYciU9Y/1wrN6T9vNhVa6faeW7JwvpYtqtfhEyOpry1dOF/jCenq/9w3ZY+6N57lXDWVz7qyPX6WJI89EcxObw2d636GlTbIY7p8K0krSTXftkpWK9W+AAAAAAqHIBF5S7757PruU/r+Uy85Xj7Y6tc1G9rz2reu662r9JnvP6MTo+Py2dJ4YqIK8abL1+gda5aoJzyU13Tg/qH0ey4mNDGV+V8/cKFu/ulBvZCmMmo8YbTltn2qr/PqxEhsSgj3zQ+tyxp6zsZ43OjJ3tyCxEx7z710fFTtzfW688PrFR6Mqr3Frxvu+63CkamXCw0M6/Dx9NWI0+U6eCHTvnKnnzZPWy4Ozthz0el5kUtAWImDPKZzGuxRyS2m1XzbKl0l7icKAAAAoHwIEjErlmVp6aJ6x8u1Nc3Xtz68wbGyJRkWPRke0n/+1yEdnTRleSw+MZDk3o9crOXNE6FQR3uTGuf7dHwkltN6s2V88YR0cjSmrreu0l9/+6m0lxkeS2h4bEySpgyK2Lp7v7752uTWvkhUlpRxCnGujKTbfxXS2uWLHIc1ZNt7LjwY1e+PvKprNrSrJzykvsjMsDNh/rinpJNT4wmNxOIyxjg+noWanJxLQJhIJPS+bzyuIydGlTCqmEEe0zkN9qiE25BJNd82AAAAAKgllsl3MzYXCwQC6u/vL/cyasb+Q4N63zeeyHj8k5tW6uOXrXYMCZJhUe/gsLJ1Kr9uccOUUOiHT7+kj92V23RgJ//XmtP1o2eO5jlzeWIvsbuu3aCO9ib1hId0T0+ffvDkizo1xzBRmmgBnuf1ZK2uu6enT//v/c9oNMMdN7EXoV/vWLNE//Hw83nfvsmSbcltLQ0Fq/TLVG2Y3LvxY3c+qcHhU1OCYI89sX/bzz/5Jv34wBH93fd+q+Mj42mv32tb2vGms3Tp2YsluXuKblKlt2hnU823DQAAAACqRbZ8jSARs2aM0Zv++eG0gzqWN83Xo59+S06ViJt27s2pNdhrW/r2jg2pFjxjjC75p1+of2h09jdijub7bH3uXWt0RcdySRN7KF516xOKFSBInMy2pNYF8/S1qy5IDXvoH4rqfd94XC8dz377bUuyLSun/SxzkQzy5lrpl6na8J/ec54+fd/TCg8OK1P3us9jqbWhTocnVa5m4rOlZNFlvc/WeMJUXNszAAAAAAClki1fY2ozZs2yLH372g1a0eqXx5bqPJY8tnRWq1/fue7inEKmTK256diWlZruaozR/kODOmdpo+qdRi4X0WgsoejYeGoK8kVti2Y11dpJwkhHXz2l93/jCXX8zwf1sTt/rXf9+3/psEOImPzefENE25Ka/b60xyYPXnEyeZp0ckp08uvJvR2nT63+wK1PKDSQOUSUJvaRzCVElP4YIkoTbdyzmY6d6XY4HQMAAAAAoJqwRyLmJNDk1y8+dems2xVDA8PyeiyNxZ0vmzBGwdYG9Q9FdcXXf6XDJ3ILkortH/7X7zTP55laUXfv02kHt8xVQtLgyTH98LdHCn7dU36OkSLRzPtPem0rNXglU7tqtv0ND58Yzbi3Yw5PhTm1aCd/Tngwqu5QROtWZJ9ane12SKr4IS8AAAAAAOSK1mYUTD77nyUv+/Dvj+qWR1/IqWLudYsb9PNPvklv+fIjCg3mNmm41JJtv5+8LPPglmrgsaTvXPcGLV04P22QlhxAM71l3bYmpm9fcdFy7f6vQzkPeimWxafV6XsffaOOvDKa9nmbqfXeY1tqb66XZKUmYU8+NpvWb/YPBAAAAAC4QbZ8jYrEKpNIJHTHvl498+IJrVm2UB9c3ybbzq31dy5BRraqrWWL6qdc7xmn1en9t+7TyydG5bGVdcDKZLF4Qj858HLaPRndItn2+5n7D5R7KUVlJF24fKHe+pVfpkK2ydOSr7zlCQ28OpZ2SvSxV8f09b3PZ52kXSqDr47pLV9+RMYY1aUZbJN1KnYkKktW2mPJ1u/kfp5OcplODQAAAABAuVGRWEV6QhF9YNqgD59nYh/DDodAYy5BRraqrTMXzlM8Ib38yqhsa+p+dfny2Jaa/T4NnhxTeevYspvnnbj/3BCUFVPXW1fpa794XmNpNjO0pdda1vO/Ezy2su6PWGyTKwrv/XW/bnzggKJpeu/rPJYkK+3t99d5dNPl56SG8GST7fwpxFAbAAAAAADywbCVGpBIJGaEiJIUixt94NYnlEhMhB3xeFyf+98HdMXXf6XP/e8DisfjWQdf5DKQIlvVVt/QqF46Maq4mVuImLy+Yy4PEaWJwSY+T+FOrVwiJE8ZcqZbf3lImW5mQppViChJ7zp/WU63uVgmVxQGWxsUy5Bqxo1RIsO5EYsnFGxtyOnnZTt/ch1qAwAAAABAKRAkVomvPfz8jBAxKRY3umNfr37828N63d/9RLc9FlJ3aEi3PRbS6/7uJ/q3Xzw7pyAjOTClFk0fzuyxLS1pnKd4Yu5xp21J7c1+BVv8jifqLDO7OTl5alyncu1Lz1G9z9aShfNzfj7l8guszmPp3ecvzRh6puPz2AoNDKujvSntFO6JPRL9astwrK3Zr472ppx+VrbzJ7kOAAAAAADcgCCxwhljtP/QoL72i2ezXu63fcf10Tt/k/bYzp8/K9tKn0TlEmRkq9oqB68tLar3ymtPtHYX0/T2ZduSvvr+C7R0Uf2cr3tFa4O+fOX5kiVZtuR1WVZrzMzbP1fjCaNLz148Ed45tPP66zy6buNZWrxg3oxAd8o6JV21oV3tLQ0zQr9MkhWFlmVpz7Z1am/xy+ex5K/zyOeZaDn+1oc3aM/29Mf2bF+fcztytvMnn8pGAAAAAACKjWErFax/KKrNt020JMcd2o/7j2cfUDI2PvsWzWTV1vQ93solYaT3XBhQndfWtx4Pp4aAlEI8YfTpe/+/ObfmNvl9+tknLtFbv/JL9UZGyrpnYK7qfbbGxif2hpzNsyBZydcZbNaebeu0edd+9Q5GM070jsUTesufnqGrN7Rr82379UKawDvddU7eB1SaeMwm/4jpFYWBJr8e6tqYcRBRtmO5yHT+5FvZCAAAAABAsTFspUIZY7Txnx9RbyTqeFnbki5qW6Tu8PGMl5nvtRVLmLyHPRhj1B2K6P4n+/X937ykkQK3us6FpdkFWnPlsSVLVsYALKfrsCzd+Bd/qn/84e/TDvNwG69tacebztKShfP1uf/9u4xt9kkeS7Jta8q05LbmiUq+Za9VcyafWx+76zcTA3amhX2Tn5vGGP3omcP67AMHFBkeU53H1njCpL3OyaHfksZ52rK7e0q4OP17SiHdsKNyrAMAAAAAgGz5GkFihdp/aFDv+8YTOV32XeedoXk+r+7+9YsZL/O+iwJ67PkBvXxiVF6PrXgiofaWBn1z2zodPjE6o9rKGKMfPv2SPn3fb9NOtK0UtlX49tw6j6WE0ZyCRElaUOfRuDEaneuUmhKY77P1uXet0XsvCmjTzr0KDQxnvF89tqUb/+L1+uD6Nv2697hjJV8+Idv0oDCX6sDZfE8xuGUdAAAAAIDaRpBYhf7pJ/9H//HICzlddu2y0/TM4ZNZg62zWhvUNxSVx7IUSxid0ThPX73yAl3/vadTAc7YeEJN/jr9j02v07/87KCGRio3QJQknz0RIhZ6UInHLs7+gXNV5514DCXJ67FkEkbzvLaiBQoq775ug9ataFH/UFTX3LZPhwZmVsvmUuWaTqaQjfANAAAAAIDCIkisMv1DUf35v/5Sx0fGC3J9TX6fXhkdn9LWbFsToc/0/eOQnW1JwRa/RscTeun4aEGuc3qLtseyZNsT4ZosS+MOSahtSUsWztcnL1ut9ha/JCk8GFWwtUGJREJX3rKvIOtMBonSxNp+/MwR3fiDAxqKjqnOW/h23XSVisub/dqzbZ0CTf45Xz8AAAAAALUoW77GsJUKY4zR5l37daJAIWKdx9IrI+MzhrUkjJQodKleDVjR2qA929crkTB6882PzLm9WZpoGx6LJ1T3Wlh2euM8bXlDu46+ekovHBvWo384lrWqcnmTX3ft2DAlvEsGfvsPDc55fZJU7/MoPBhNXa9lWXrnuUv1jjVLCl4xmNo78c4nNTh8Sgmj1ECd8GBUW3btz7viEQAAAAAAOCNIrBCJREJ37OvVw78/qvBgtGBDRGJxI49tlWcqSZnVeSyN5RmWWpIuaFukF44N6+Spcfk8lsbiCTU31Ommy9foHWuWyLIs9Q9F1dLg08uvjs15nbG4kSVL9T6vGustHX1lVF/88UEZOQ+Umagslc5cOD/t8fBgVPU+WyNzbG8eT6Sf7m1ZljqDzeoMNs/p+pOSVYjhweG0k6zjCaPeSFQ94aGC/UwAAAAAADCBILEC9IQiev8tj6sYA5GN5j4UpBItrPfp1dFY3t9nJL1w7KR+/ZnL9Ju+EwoNDE9pF+4JD+mitkW65rZ9OYeITgNfko9PJDrz+pweuYSR+oZGMgZrwdaGnB//ZLt7wmjGdO+2Zr862ptyup7ZSlbjhgejaUPEJJ/HVmhgmCARAAAAAIACI0h0uUQiUbQQsZa9MpJ/iJh0fGRcl/zzI7r7ujdo6cL5M/bpW3zaPL18Irf9Eef7bJ02z6djJ0/Nej1OsgVrHe1NWt7sfy2cm7lHZvL7k/sb/tN7z9Pf3vt02gnKxW4l7gkPqT8yMmWd6cTi6asjAQAAAADA3BAkuty3nggTIhZBtijK57EUc2h5Pnx8VJtv2yfJUjgyEcIl9+k7cmI05wE18YTRv199gY6dPKXP/uCAIsMTVYeF3J4yW7BmWZb2bFs3Iwxta/brm9vW6fCJ0Rn7Gz7UtbHok5LTTWMODQzL67E0lmVYeKmqIwEAAAAAqEUEiS73yMFj5V5CTfBY0t//xev1p0sbFR6M6lfPDej7T72U8fJGUjgSlSVrRoVcriGibUltzX51BpsnhpOsWaqe8JAe/v1R3fLoC7NqOZ/eJp1LsBZo8mcMBwNN/hmVjIXe93C6TNOYP/W21Ypl6Wn22pbaW0pTHQkAAAAAQC0iSHS5RX5fuZdQsc5onKd5XluHT4zK57F1ajyhRMKkrUac5/PIX+fVuhUtWreiRe0t/qxBoiR5LEuZxp04DUGRpNYF86aEXsmArqO9ST85cGRGu3HWtdiWAovqZdtS/9BI3m3HxQ4HczV1H0QzZRrzl396UMub/KkK0CTbkloW1Onfr7owFcoCAAAAAIDCI0h0uSsuPFPffzJ7oIU/qq+z9aZVi7XtjUGtW9EiSalKu5FYXP/wvw6kbRWf3v7bGWxWW7NfvZFoxp8VN0aZIiuvx1JDnUfHR8bTHvfY0teuukDLFtXPOJap3XjpwvmSLL10fGLYSHJqs9djpQLDMxfOL3rbcTFl2gcxnjDqGxrRV99/gW7+2cG0ezSmuy8BAAAAAEDhECS63M//D63N2Sys92j7n71OSxfOzxicJSvtjDG6/VehGZV+6dp/LcvSXdeu1zX/uU+HBmeGiR7bUntzvSbvkTj9+n72iUt0yT8/osPHR6dUJ3psS8GWmS3Dk2VqN5YmwrZDx05qdDyhep9nxu12Q2Whk3R7IFqWlXUfRJ/H1vCp8ZLs0QgAAAAAAGayjDEFHOtQXoFAQP39/eVeRkG96Z9+od7ISLmX4UrLFs3XLz/9Ztm2nfP3pNt/L1tFmzFGP37miG78wQENRcdU5536PclW3EzXl+/PqwWZ9kDc89pwl6tufSLtsBufx9Jd125wfUgKAAAAAEAly5avESS6XMfnfqqB4fTtsbWu67JVGn2tT/nSsxfnvD9epmq42X6P0/XN5udVK2OMNu3cm7YqNNji188/+SZd9i+PZjz+YNfGmr3vAAAAAAAoBYLECnbxF3+ul46PlXsZFaGt2a+7rl2vQJO/JD/PGKPuUCQ1WTufMLNWdYciuvrWfRpLM305WXG4dOF8qjgBAAAAACiTbPkaeyS6XL1dNTlv0fVGotqya39Jqtb6h6L6wK1PqG9S2/l/PPL8nMPMaq9edNoDMTQwrM5gM/sgAgAAAADgQq4NEp999llt2bJFAwMDWrhwoW6//Xadc8455V5WSRlj9HwkVu5lVJTwYFQ94aGi7qNnjNE1t+2bEiImzSXMzLZ3YKmqLIst2NqgWJpqRGnq5GzLsipiaAwAAAAAALUk9ykVJXbddddpx44d+sMf/qDrr79eW7duLfeSSu6xg4fLvYSysS2ps32R/HX5PUXt1yb/FlNPeChtiJiUDDPzkRzaEh6MKhY3io7FFYsbhQcngslq2YGgo71Jy5v98thTQ9Z0k7MBAAAAAIC7uDJIPHr0qHp6evTBD35QkvSe97xHfX19eu6558q8stLafPuT5V5CWXhsSytaG3T3Ry7WgZverruv26C/uvR1+qtLX6d/uPz1srMU+iWMSVW1FUtoYDjrGmYTZvaEh9QfGZkyYESS4gmj3kj+waRbWZalPdvWqb3FL5/Hkr/OI59nYpDKnu3raV8GAAAAAMDFXNna3NfXp6VLl8rrnVieZVlqa2tTb2+vVq5cWebVlU511KBlZ1tKVadNH6yRDJXWrWjRuhUtkiYq93b/KqRDA9G019feUvyqtmBrg+JZKgRnE2bmundgNQg0+dkDEQAAAACACuTKIDFXO3fu1M6dO1P/PnnyZBlXU3v+46oLdP33fqtXR8dz/p6GOo/G4okpoeE3t63T4ROjOYVKlmXpW9vXzxh0Ik2EiKWoautob1Jbs7+gYWauewdWC/ZABAAAAACg8ljGhZuvHT16VCtXrlQkEpHX65UxRkuXLtVjjz2WtSIx23jqShS84YflXkJaTfVePfA//kzLmxv0zV8d0o0P/C7n773p8tfr9WcunHMlmjFG3aGIHjl4TJJ06dmL1RlsLllVW7qpzdJEiHjXtRu0bFF9XtdnjNGmnXsVHoxOaW/22BNtv6WYRA0AAAAAAJAtX3NlkChJl156qbZu3aqtW7fq3nvv1Re/+EX19PRk/Z5qCxIPHTqkN38j95AuF7akeV5bY+MJTe+itS3pHy4/R6vOWKCHfndED/3+mIbH4gq2+HV+YKE8Hs+MwC6RSGj1Z36s8fTFdFP4PJYOfu7tsm1Xbs2Zt0KHmemmNifbvPMNJgEAAAAAAGajIoPEgwcPauvWrRocHFRjY6N2796tc889N+v3VFuQKBWmKtGStP2SFfp/3vEnqRDPGKP9hwb1nf19OjES06VnL9YHN7TPKuTrCUX0/lsezxom+jyWvrPjDbqIqbxZGWPYOxAAAAAAAJRNRQaJs1GNQaKUuTKxud6jEyNxxTURFi6Y79ElK1v1lfedp+/8+iU98+IJrVm2UB9c31b0KsBEIqFvPRHWIwePaZHfpysvCujg0ZM68NIrJVsDAAAAAAAA5oYgEQAAAAAAAICjbPkaJWIAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMARQSIAAAAAAAAARwSJAAAAAAAAABwRJAIAAAAAAABwRJAIAAAAAAAAwBFBIgAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEeWMcaUexGFMm/ePC1evLjcyyiakydPasGCBeVeBoA0OD8Bd+LcBNyL8xNwJ85NwL1KdX4eO3ZMp06dSnusqoLEahcIBNTf31/uZQBIg/MTcCfOTcC9OD8Bd+LcBNzLDecnrc0AAAAAAAAAHBEkAgAAAAAAAHBEkFhBurq6yr0EABlwfgLuxLkJuBfnJ+BOnJuAe7nh/GSPRAAAAAAAAACOqEgEAAAAAAAA4IggEQAAAAAAAIAjgkQAAAAAAAAAjggSK8Szzz6riy++WKtXr1ZnZ6cOHDhQ7iUBFe3jH/+4gsGgLMvSU089lfp6tnOt1MeAWjQ6Oqp3v/vdWr16tc4//3y99a1v1XPPPSdJOnr0qN7+9rdr1apVWrNmjR599NHU95X6GFCr3va2t+m8887T2rVrdckll+jJJ5+UxOsn4Ba7d++WZVm6//77JfHaCbhBMBjU2WefrbVr12rt2rX67ne/K6mCXzsNKsKb3/xms3v3bmOMMffcc4/p6Ogo74KACrd3717T19dn2tvbzZNPPpn6erZzrdTHgFo0MjJifvjDH5pEImGMMebf/u3fzMaNG40xxnzoQx8yN954ozHGmP3795tly5aZsbGxshwDatXQ0FDq/3/ve98z5513njGG10/ADQ4dOmTe8IY3mA0bNpjvf//7xhheOwE3mP6eM6lSXzsJEivAyy+/bE477TQTi8WMMcYkEglzxhlnmGeffbbMKwMq3+Rf6tnOtVIfAzChu7vbtLe3G2OMaWhoMIcPH04d6+zsND//+c/LcgyAMbt37zbnn38+r5+AC8TjcbNp0ybT09NjNm7cmAoSee0Eyi9dkFjJr53e2dUxopT6+vq0dOlSeb0TD5dlWWpra1Nvb69WrlxZ5tUB1SPbubZw4cKSHuPcBiZ89atf1bve9S4NDg4qFotpyZIlqWPBYFC9vb0lPwbUus2bN+vhhx+WJP3oRz/i9RNwgZ07d+qNb3yjLrrootTXeO0E3GPz5s0yxmjdunX64he/WNGvneyRCAAAXOnzn/+8nnvuOX3hC18o91IATLJnzx719fXpH//xH3X99deXezlAzXvmmWd033336TOf+Uy5lwIgjUcffVRPP/20fvOb36i1tVVbtmwp95LmhCCxAixfvlyHDx/W+Pi4JMkYo97eXrW1tZV5ZUB1yXaulfoYUOtuvvlmfe9739OPf/xj+f1+tbS0yOv16siRI6nLhEIhtbW1lfwYgAlbtmzRww8/rEAgwOsnUEa//OUvFQqFtGrVKgWDQT3xxBPasWOH7r77bl47ARdIngM+n0+f+MQn9Mtf/rKi33sSJFaA008/XRdeeKHuuOMOSdJ9992nQCBA6wZQYNnOtVIfA2rZzp079e1vf1s///nPtWjRotTXr7jiCn3961+XJHV3d+vFF1/Uxo0by3IMqEXHjx/XSy+9lPr3/fffr5aWFl4/gTL76Ec/qsOHDysUCikUCmnDhg265ZZb9NGPfpTXTqDMhoeHdfz48dS/v/3tb+uCCy6o7NfOvHdVRFn8/ve/Nxs2bDCrVq0yF110kXn66afLvSSgou3YscMsW7bMeDwec/rpp5vXve51xpjs51qpjwG1qK+vz0gyZ511ljn//PPN+eefb9atW2eMMebIkSPmrW99q1m5cqV5/etfb37xi1+kvq/Ux4BaFAqFTGdnp1mzZo0577zzzKZNm1Kbx/P6CbjH5GErvHYC5fX888+btWvXmnPPPdesWbPGXH755ebQoUPGmMp97bSMMWb22SoAAAAAAACAWkBrMwAAAAAAAABHBIkAAAAAAAAAHBEkAgAAAAAAAHBEkAgAAAAAAADAEUEiAAAAAAAAAEcEiQAAAAAAAAAcESQCAAAAAAAAcESQCAAAAAAAAMDR/w9Xid7hbdTzhgAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "19ecfb73fc7233cb"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
